[sdoi2015]排序（搜索+剪枝优化）

Description

小A有一个1-2^N的排列A[1..2^N],他希望将A数组从小到大排序,小A可以执行的操作有N种,每种操作最多可以执行一次,对于所有的i(1<=i<=N),第i中操作为将序列从左到右划分为2^{N-i+1}段,每段恰好包括2^{i-1}个数,然后整体交换其中两段.小A想知道可以将数组A从小到大排序的不同的操作序列有多少个,小A认为两个操作序列不同,当且仅当操作个数不同,或者至少一个操作不同(种类不同或者操作位置不同).

  下面是一个操作事例:

  N=3,A[1..8]=[3,6,1,2,7,8,5,4].

  第一次操作,执行第3种操作,交换A[1..4]和A[5..8],交换后的A[1..8]为[7,8,5,4,3,6,1,2].

  第二次操作,执行第1种操作,交换A[3]和A[5],交换后的A[1..8]为[7,8,3,4,5,6,1,2].

  第三次操作,执行第2中操作,交换A[1..2]和A[7..8],交换后的A[1..8]为[1,2,3,4,5,6,7,8].

Input

第一行,一个整数N

第二行,2^N个整数,A[1..2^N]

Output

一个整数表示答案

Sample Input

3
7 8 5 6 1 2 4 3

Sample Output

6

HINT

100%的数据, 1<=N<=12.

题解：

......搜索送命题

对于菜得不能再菜的垃圾博主，搜索真是这世界上最难的算法（dalao勿喷）。

考试时看到这题，觉得是道数学题或者是一道数据结构加数学题，结果看题解发现是一道搜索。

不会写搜索的垃圾博主当场吓尿。

但考试时输出阶乘qj测试点得了15pts，运气不错

咳咳...言归正传

其实首先要想到一个性质就是对于一个操作序列的顺序是不影响他的合法性的，也就是说每次多加一种操作对答案的贡献是阶乘的这也就是我没爆零的原因。

那么我们就只需要确定每个操作是不是要选就可以了。

我们从小到大dfs，dfs（now，x）表示选了now种方法，现在判断第x种方法。

显然递归入口dfs（0，1）。

然后我们考虑怎样剪枝。

实际上交换的过程就是把不合法的子序列进行交换得到合法的子序列。

然后我们就可以每次扫一遍，找出对于每次操作x，不合法的序列个数及不合法序列的开始位置以便交换。

如果有两个以上不合法的子序列那就完戏了，直接return。

如果没有不合法的子序列，那么就不需要进行这种操作，直接搜下一层。

如果有一个这种子序列，那么交换他的前一半和后一半，再判断是否合法，再进行搜索。

如果有两个这种子序列，那么判断四种情况，在进行搜索。

很多神犇只说四种情况，并没有说明白是哪四种情况，坑害了我这种懵逼的蒟蒻

其实也很好想就是判断前一段的前一段和后一段的前一段交换，前一段的后一段和后一段的前一段，前一段的前一段和后一段的后一段，前一段的后一段和后一段的前一段。

就似这四种情况辣。

另外还有要注意的是就是在写交换和判断两个过程时一定要处理好循环的边界问题，博主就因为这个被卡了好长时间。

（附上本人丑陋的代码）、

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<queue>
 #include<vector>
 #include<algorithm>
 using namespace std;
 int fac[],power[];int n;int num;
 int a[<<|];
 int  res=;
 int qpower(int a,int b){
     int ans=;
     while(b){
         if(b&) ans=ans*a;
         b>>=;
         a=a*a;
     }
     return ans;
 }
 int check(int x,int k){
     for(int i=;i<power[k];i++){//不要右边界
         if(a[x+i]!=a[x+i-]+){
             return ;
         }
     }
     return ;
 }
 void swap(int x,int y,int k){
     for(int i=;i<power[k];i++){//左右边界都不要
         int t;
         t=a[x+i];
         a[x+i]=a[y+i];
         a[y+i]=t;
     }
 }
 void dfs(int now,int x){
     //cout<<x<<" "<<now<<endl;
     if(x==n+){
         res+=fac[now];
         return ;
     }
     int pos1=;int pos2=;int cnt=;
     for(int i=;i<=num;i+=power[x]){
         if(check(i,x)){
             cnt++;
             if(cnt>=) break;
             if(!pos2){
                 if(!pos1){
                     pos1=i;
                 }
                 else pos2=i;
             }
         }
     }
     //cout<<cnt<<" "<<pos1<<" "<<pos2<<endl;
     if(cnt>) return ;
     if(cnt==){
         dfs(now,x+);
     }
     if(cnt==){
         swap(pos1,pos1+power[x-],x-);
         dfs(now+,x+);
         swap(pos1,pos1+power[x-],x-);

     }
     if(cnt==){
         swap(pos1,pos2,x-);
         if(check(pos1,x)||check(pos2,x)){
             swap(pos1,pos2,x-);
         }
         else{
             dfs(now+,x+);
             swap(pos1,pos2,x-);
         }
         swap(pos1,pos2+power[x-],x-);
         if(check(pos1,x)||check(pos2,x)){
             swap(pos1,pos2+power[x-],x-);
         }
         else{
             dfs(now+,x+);
             swap(pos1,pos2+power[x-],x-);
         }
         swap(pos1+power[x-],pos2,x-);
         if(check(pos1,x)||check(pos2,x)){
             swap(pos1+power[x-],pos2,x-);
         }
         else{
             dfs(now+,x+);
             swap(pos1+power[x-],pos2,x-);
         }
         swap(pos1+power[x-],pos2+power[x-],x-);
         if(check(pos1,x)||check(pos2,x)){
             swap(pos1+power[x-],pos2+power[x-],x-);
         }
         else{
             dfs(now+,x+);
             swap(pos1+power[x-],pos2+power[x-],x-);
         }
     }
 }
 int main(){
     fac[]=;power[]=;
     for(int i=;i<=;i++){
         fac[i]=fac[i-]*i;
         power[i]=power[i-]<<;
     }
     scanf("%d",&n);
     num=qpower(,n);
     for(int i=;i<=num;i++){
         scanf("%d",&a[i]);
     }
     dfs(,);
     //for(int i=1;i<=15;i++) cout<<power[i]<<" "<<fac[i]<<endl;
     //cout<<power[15];
     printf("%d",res);
 }

丑陋得不能再丑陋的代码

一道看题解后完全自己码出来，调出来的代码，还是很高兴的。

搜索水平还是太弱了啊，考试时都不知道暴力怎么打，一定要提升搜索的水平啊