bzoj3990: [SDOI2015]排序 dfs 数学

bzoj3990: [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.

分析

很神的一道搜索题。
首先可以想到的是这里的每一个操作都是独立存在的，所以操作的顺序不影响答案。也就是对于一个长度为$n$的操作序列，对答案的贡献是$n!$
接下来我们考虑每一步。对于操作i，它唯一可以做到的是调整$2^{n-i}$段区间长度为$2^i$的区间内部顺序(因为它可以交换$2^{n-i+1}$段长度为$2^{i-1}$的区间)
并且只有这个操作可以调整，如果过了这个操作别的操作都无法调换这$2^{n-i}$段区间长度为$2^i$的区间内部顺序。这就是所有操作“互不影响”，“独立存在”的含义。
那么对于一次操作，我们考虑它可调整的区间需要满足的条件。

1. 如果有两个以上的区间需要调整，那么由于我们只能交换一次，所以不合法。
2. 如果没有区间需要调整我们直接往下做
3. 如果只有一个区间需要调整，我们调整这个区间的内部顺序，继续往下做。
4. 如果有两个区间需要调整，我们枚举四种交换方法，如果有方法合法，就往下做（好像只有一种是合法的）
   讨论一下就是dfs咯。

代码

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int N = 1100;
const double eps = 1e-3;
int read() {
    char ch = getchar(); int x = 0, f = 1;
    while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
    while(ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}
int bin[13], f[13], a[11000], n;
long long ans;
bool check(int st, int k) {
    for(int i = 1;i < bin[k]; ++i)
        if(a[st + i - 1] + 1 != a[st + i])
            return false;
    return true;
}
void swap(int s1, int s2, int k) {for(int i = 0;i < bin[k]; ++i) swap(a[s1 + i], a[s2 + i]);}
void dfs(int k, int cnt) {
    if(k == n + 1) {
        if(check(1, n)) ans += f[cnt];
        return;
    }
    int t1 = 0, t2 = 0;
    for(int i = 1;i <= bin[n]; i += bin[k])
        if(!check(i, k)) {
            if(!t1) t1 = i;
            else if(!t2) t2 = i;
            else return;
        }
    if(!t1 && !t2) dfs(k + 1, cnt);
    else if(t1 && !t2) {
        swap(t1, t1 + bin[k - 1], k - 1);
        dfs(k + 1, cnt + 1);
        swap(t1, t1 + bin[k - 1], k - 1);
    }
    else {
        for(int p1 = 0;p1 <= 1; ++p1)
            for(int p2 = 0; p2 <= 1; ++p2) {
                swap(t1 + bin[k - 1] * p1, t2 + bin[k - 1] * p2, k - 1);
                if(check(t1, k) && check(t2, k)) {
                    dfs(k + 1, cnt + 1);
                    swap(t1 + bin[k - 1] * p1, t2 + bin[k - 1] * p2, k - 1);
                    break;
                }
                swap(t1 + bin[k - 1] * p1, t2 + bin[k - 1] * p2, k - 1);
            }
    }
} 
 
int main() {
    bin[0] = 1; for(int i = 1;i <= 12; ++i) bin[i] = bin[i - 1] << 1;
    f[0] = 1; for(int i = 1;i <= 12; ++i) f[i] = f[i - 1] * i;
    n = read();
    for(int i = 1;i <= bin[n]; ++i) a[i] = read();
    dfs(1, 0);
    printf("%lld\n", ans);
    return 0;
}