bzoj3990

排序

HYSBZ - 3990

小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 Output6
Hint100%的数据, 1<=N<=12.

sol：从小段到大段搜，一段段分开后，如果有两段以上不是严格升序就挂了，如果只有一段就换一下接着搜，两段的话就是交叉互换，满足条件接着搜

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read()
{
    ll s=;
    bool f=;
    char ch=' ';
    while(!isdigit(ch))
    {
        f|=(ch=='-'); ch=getchar();
    }
    while(isdigit(ch))
    {
        s=(s<<)+(s<<)+(ch^); ch=getchar();
    }
    return (f)?(-s):(s);
}
#define R(x) x=read()
inline void write(ll x)
{
    if(x<)
    {
        putchar('-'); x=-x;
    }
    if(x<)
    {
        putchar(x+''); return;
    }
    write(x/);
    putchar((x%)+'');
    return;
}
#define W(x) write(x),putchar(' ')
#define Wl(x) write(x),putchar('\n')
const int N=;
int n,a[N];
ll ans=,Jiec[],Bin[];
inline bool Check(int Pos,int K)
{
    int i;
    for(i=;i<Bin[K];i++) if(a[Pos+i-]+!=a[Pos+i]) return false;
    return true;
}
inline void Swap(int P1,int P2,int K)
{
    int i;
    for(i=;i<=Bin[K];i++) swap(a[P1+i-],a[P2+i-]);
}
inline void dfs(int K,int Step)
{
    if(K==n+)
    {
        ans+=Jiec[Step]; return;
    }
    int i,op1,op2,p1=,p2=;
    for(i=;i<=Bin[n];i+=Bin[K]) if(!Check(i,K))
    {
        if(!p1) p1=i;
        else if(!p2) p2=i;
        else return;
    }
    if(!p1) dfs(K+,Step);
    else if(!p2)
    {
        Swap(p1,p1+Bin[K-],K-);
        dfs(K+,Step+);
        Swap(p1,p1+Bin[K-],K-);
    }
    else
    {
        for(op1=;op1<=;op1++) for(op2=;op2<=;op2++)
        {
            Swap(p1+op1*Bin[K-],p2+op2*Bin[K-],K-);
            if(Check(p1,K)&&Check(p2,K))
            {
                dfs(K+,Step+);
                Swap(p1+op1*Bin[K-],p2+op2*Bin[K-],K-);
                break;
            }
            Swap(p1+op1*Bin[K-],p2+op2*Bin[K-],K-);
        }
    }
    return;
}
int main()
{
    int i;
    Jiec[]=; for(i=;i<=;i++) Jiec[i]=1ll*Jiec[i-]*i;
    Bin[]=; for(i=;i<=;i++) Bin[i]=Bin[i-]<<1ll;
    R(n);
    for(i=;i<=Bin[n];i++) R(a[i]);
    dfs(,);
    Wl(ans);
    return ;
}
/*
input
3
7 8 5 6 1 2 4 3
output
6
*/