題目描述

輸入輸出格式

共兩行。第一行為鐵盤個數N（1<=N<=50)，第二行為N個不同的正整數，分別為從上到下的鐵盤的半徑R。（1<=R<=100）

一個正整數，表示使鐵盤從小到大有序需要的最少翻轉次數。

輸入輸出樣例

5
2 4 3 5 1

5

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define inf 999999999
#define For(i,a,b) for(i=a;i<=b;++i)
#define rep(i,a,b) for(i=a;i>=b;--i)
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
using namespace std;
int read(){
    int sum=0,flag=1;
    char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')flag=-1;c=getchar();}
    while(c>='0'&&c<='9')sum=sum*10+c-'0',c=getchar();
    return sum*flag;
}
int maxx(int x,int y){
    if(x<y)return y;
    return x;
}
int minn(int x,int y){
    if(x<y)return x;
    return y;
}
int abss(int x){
    if(x>=0)return x;
    return -x;
}
const int maxn = 100010;
int a[51],b[51];
struct node{
    int s[51],t;
};
int n,cnt;
node tmp;
void bfs(){
    int i,j;
    node T;
    memcpy(T.s,a,sizeof(a));
    T.t=0;
    queue<node>q;
    q.push(T);
    while(!q.empty()){
        T=q.front();
        q.pop();
        int jicun=n;
        while(T.s[jicun]==b[jicun])jicun--;
        For(i,2,jicun){
            memcpy(tmp.s,T.s,sizeof(T.s));
            int k=i>>1;
            For(j,1,k){//直接翻轉
                int ch=tmp.s[j];
                tmp.s[j]=tmp.s[i-j+1];
                tmp.s[i-j+1]=ch;
            }
                tmp.t=T.t+1;
                if(memcmp(tmp.s,b,sizeof(b))==0){//如果到達目標狀態則結束
                    printf("%d\n",T.t+1);
                    return ;
                }
                q.push(tmp);
        }
    }
}
int main(){
    int i,j;
    n=read();
    For(i,1,n){
        a[i]=read();
        b[i]=a[i];
    }
    sort(b+1,b+n+1);
    if(memcmp(a,b,sizeof(b))==0){
        printf("1\n");
        return 0;
    }
    bfs();
    return 0;
}
 

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define inf 999999999
#define For(i,a,b) for(i=a;i<=b;++i)
#define rep(i,a,b) for(i=a;i>=b;--i)
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
using namespace std;
int read(){
    int sum=0,flag=1;
    char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')flag=-1;c=getchar();}
    while(c>='0'&&c<='9')sum=sum*10+c-'0',c=getchar();
    return sum*flag;
}
int maxx(int x,int y){
    if(x<y)return y;
    return x;
}
int minn(int x,int y){
    if(x<y)return x;
    return y;
}
int abss(int x){
    if(x>=0)return x;
    return -x;
}
const int maxn = 100010;
int a[51],b[51];
struct node{
    int s[51],t;
};
int n,cnt;
int trie[2000000][51];
node tmp;
int pd(){//字典樹部分
    int i,u=0,flag=0;
    For(i,1,n){
        if(!trie[u][tmp.s[i]]){
            flag=1;
            trie[u][tmp.s[i]]=++cnt;
        }
        u=trie[u][tmp.s[i]];
    }
    if(flag)return 1;
    return 0;
}
void bfs(){
    int i,j;
    node T;
    memcpy(T.s,a,sizeof(a));
    T.t=0;
    queue<node>q;
    q.push(T);
    while(!q.empty()){
        T=q.front();
        q.pop();
        For(i,2,n){
            memcpy(tmp.s,T.s,sizeof(T.s));
            int k=i>>1;
            For(j,1,k){
                int ch=tmp.s[j];
                tmp.s[j]=tmp.s[i-j+1];
                tmp.s[i-j+1]=ch;
            }
            if(pd()){//判重
                tmp.t=T.t+1;
                if(memcmp(tmp.s,b,sizeof(b))==0){
                    printf("%d\n",T.t+1);
                    return ;
                }
                q.push(tmp);
            }
        }
    }
}
int main(){
    int i,j;
    n=read();
    For(i,1,n){
        a[i]=read();
        b[i]=a[i];
    }
    sort(b+1,b+n+1);
    if(memcmp(a,b,sizeof(b))==0){
        printf("1\n");
        return 0;
    }
    bfs();
    return 0;
}
 

每一次確定最末尾的那個數，步驟是第一步，把最末尾未確定的數換到第一個位置，接下來就可以換到最後了，接下來一樣的步驟，舉個例子：

對於 2 4 3 5 1，最開始要確定最後一位，也就是要把最後一位變成5，於是先把5放到第一位，->5 3 4 2 1，再換到最後1 2 4 3 5，之後5就不管他了

只剩下1 2 4 3，於是一樣的->4 2 1 3->3 1 2 4，還有3個數，3 1 2->2 1 3->1 2 3於是就排好了，算下來，最壞情況只需要2*n-1步

於是就有了第一個剪枝（大於2*n-1的情況可以直接減掉），然而有了這個剪枝還是沒有什麼用，我們還要利用另外一個原理：若兩個數在目前位置上相鄰，但在目標位置上不相鄰，則因為是翻轉，因此至少需要一步把這兩個數分開，因此從當前排列到目標排列最少就需要出現這種情況的總和。待會程式碼裡還會解釋：

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define inf 999999999
#define For(i,a,b) for(i=a;i<=b;++i)
#define rep(i,a,b) for(i=a;i>=b;--i)
#define mm(a,b) memset(a,b,sizeof(a))
#define ll long long
using namespace std;
int read(){
    int sum=0,flag=1;
    char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')flag=-1;c=getchar();}
    while(c>='0'&&c<='9')sum=sum*10+c-'0',c=getchar();
    return sum*flag;
}
int maxx(int x,int y){
    if(x<y)return y;
    return x;
}
int minn(int x,int y){
    if(x<y)return x;
    return y;
}
int abss(int x){
    if(x>=0)return x;
    return -x;
}
const int maxn = 100010;
struct node{
	int value,pos,nowpos;
};
node a[maxn];
bool cmp(node c,node d){
	return c.value<d.value;
}
int ans,n;
void dfs(int sum,int total){//sum是已走過的步數，total是當前排列到達目標狀態的預計步數
	if(!total&&a[1].nowpos==1){ans=minn(ans,sum);return;}//若目標步數為0，且第一個位置上是對的，這是為了預防如5 4 3 2 1這種情況的出現
	int i,j;
	For(i,2,n){//列舉翻前i位
		int zong=total;
		if(i<n){//如果i位置與i+1位置相鄰且預計位置不相同，則可以通過這步操作分開他們，同時預計步數減少，但要考慮換過來後第1個數和第i+1個數的位置關係
			zong-=(abss(a[i].nowpos-a[i+1].nowpos)!=1)-(abss(a[1].nowpos-a[i+1].nowpos)!=1);
		}
		if(zong+sum<ans){//若當前步數加上預計步數大於已搜到的，就剪掉
			int mid=i/2;
			For(j,1,mid){
				int tmp=a[j].nowpos;
				a[j].nowpos=a[i-j+1].nowpos;
				a[i-j+1].nowpos=tmp;
			}
			dfs(sum+1,zong);
			For(j,1,mid){//回溯
				int tmp=a[j].nowpos;
				a[j].nowpos=a[i-j+1].nowpos;
				a[i-j+1].nowpos=tmp;
			}
		}
	}
}
int main(){
	int i,j;
	n=read();
	For(i,1,n){
		a[i].value=read();
		a[i].pos=i;
	}
	sort(a+1,a+n+1,cmp);
	For(i,1,n){
		a[a[i].pos].nowpos=i;//把當前位置的目標位置記錄
	}
	int sum=0;
	ans=n*2-1;//至多搜n*2-1次
	For(i,2,n){
		sum+=abss(a[i].nowpos-a[i-1].nowpos)!=1;//如果當前排列中位置相鄰但目標排列中並不相鄰則預計步數加1
	}
	dfs(0,sum);
	printf("%d\n",ans);
	return 0;
}