【bzoj3990】[SDOI2015]排序 DFS

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.

Source

Round 1 感谢ZKY制作非官方数据

---

竟然没想到是dfs…一开始画了一颗二叉树想着交换子树什么的…后来以为是状压DP但不知道如何转移…搜索大法好啊

首先显而易见的是，若操作序列长度为k合法，那么对答案的贡献是k!。这样就只需要枚举第k种操作是否合法即可。

类似分治的思想：当处理到操作k时，已经不需要操作序号小于k的操作。

因为每种操作只能做一次，所以只需要看不合法的块数有多少即可。

一个块合法，当且仅当标号连续且递增。

对于第pos次操作，分成的若干块中，若只有一个块不合法，则交换这个块的前半部分和后半部分，看看是否合法，合法则继续搜。
若两个块不合法，则枚举第一个块的前半部分和后半部分、第二个块的前半部分和后半部分，四种交换情况，看看是否使两个块都合法，合法则继续dfs。

若不合法块数大于2直接return，为0则证明不需要此操作，继续搜即可。

这样每搜完n个操作，则产生了一个长度为k的操作序列，答案累加k!。

代码细节处理需要仔细想想…黄学长的代码好像不对…

搜索这东西思路清晰就好，我竟然神奇的过了编译就A掉了…

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int SZ = 1000010;

int n;

int num[SZ],fac[SZ];

//第pos次操作，分成2^(n-pos)段，每段2^pos个，[0,n-1] 

bool check(int pos,int k)//检查第pos次操作第k段是否递增 
{
    int now = (1 << pos) * (k - 1);
    for(int i = 1;i <= (1 << pos) - 1;i ++)
        if(num[now + i] != num[now + i + 1] - 1)
            return false;
    return true;
}

//交换第pos次操作某段的前半部分和后半部分。其中前半部分开头坐标是x，后半部分开头坐标是y 
void swap(int x,int y,int pos)
{
    for(int i = 0;i <= (1 << (pos - 1)) - 1;i ++)
        swap(num[x + i],num[y + i]);
}

int ans = 0;

void dfs(int pos,int opt)
{
    if(pos == n + 1)
    {
        ans += fac[opt];
        return ;
    }
    int p1 = 0,p2 = 0;
    for(int i = 1;i <= (1 << (n - pos));i ++) //枚举段 
    {
        if(!check(pos,i))
        {
            if(!p1) p1 = i;
            else if(!p2) p2 = i;
            else return;
        }
    }
    if(!p1 && !p2) dfs(pos + 1,opt);
    else if(p1 && !p2)
    {
        int now = (1 << pos) * (p1 - 1);
        swap(now + 1,now + 1 + (1 << (pos - 1)),pos);
        if(check(pos,p1)) dfs(pos + 1,opt + 1);
        swap(now + 1,now + 1 + (1 << (pos - 1)),pos);
    }
    else
    {

        for(int a = 0;a <= 1;a ++)
        {
            for(int b = 0;b <= 1;b ++)
            {
                int now1 = (1 << pos) * (p1 - 1) + 1 + a * (1 << (pos - 1));
                int now2 = (1 << pos) * (p2 - 1) + 1 + b * (1 << (pos - 1));
                swap(now1,now2,pos);
                if(check(pos,p1) && check(pos,p2)) dfs(pos + 1,opt + 1);
                swap(now1,now2,pos);                
            }
        }
    }
}

int main()
{
    scanf("%d",&n);
    fac[0] = 1;
    for(int i = 1;i <= n;i ++) fac[i] = fac[i - 1] * i;
    for(int i = 1;i <= (1 << n);i ++) 
        scanf("%d",&num[i]);
    dfs(1,0);
    printf("%d",ans);
    return 0;
}

/*

2
1 3 2 4

2
1 4 2 3

*/