Description
小AAA有一个1−2N1-2^N1−2N的排列A[1..2N]A[1..2^N]A[1..2N],他希望将AAA数组从小到大排序,小AAA可以执行的操作有NNN种,每种操作最多可以执行一次,对于所有的i(1<=i<=N)i(1<=i<=N)i(1<=i<=N),第i中操作为将序列从左到右划分为2N−i+12^{N-i+1}2N−i+1段,每段恰好包括2i−12^{i-1}2i−1个数,然后整体交换其中两段.小AAA想知道可以将数组AAA从小到大排序的不同的操作序列有多少个,小AAA认为两个操作序列不同,当且仅当操作个数不同,或者至少一个操作不同(种类不同或者操作位置不同)。
Sample Input
3
7 8 5 6 1 2 4 3
Sample Output
6
首先有一个性质:
首先操作的顺序是无所谓的。
根据这个,我们考虑去做搜索。
考虑从小操作往大操作做。
假设当前为第iii步,则将整个序列分成每个大小为2i2^i2i的块。
若当前有一个块满足区间内的值不递增且不连续,那么肯定是在当前这次操作中将它交换,否则后面就没有交换的机会了。
若只存在一个不合法的区间,交换判断交换后是否合法。
若存在两个不合法区间,分四种情况讨论。
若不存在,直接继续做。
其他情况明显无解,直接跳出。
#include <ctime>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;
typedef long long LL;
int _max(int x, int y) {return x > y ? x : y;}
int _min(int x, int y) {return x < y ? x : y;}
int read() {
int s = 0, f = 1; char ch = getchar();
while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
while(ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
int n, a[1 << 12], bin[13];
LL ans, jc[13];
void dfs(int k, int s) {
if(k == n + 1) {ans += jc[s]; return ;}
int t = 0, o1, o2;
bool bk;
for(int i = 0; i < (bin[n]); i += bin[k]) {
bk = 0;
for(int j = i + 1; j < i + bin[k]; j++) if(a[j] != a[j - 1] + 1) {bk = 1; break;}
if(bk) {
t++;
if(t == 1) o1 = i;
else o2 = i;
}
} if(t > 2) return ;
if(t == 1) {
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + i], a[o1 + i + bin[k - 1]]);
bk = 0;
for(int i = 1; i < bin[k]; i++) if(a[o1 + i] - 1 != a[o1 + i - 1]) {bk = 1; break;}
if(!bk) dfs(k + 1, s + 1);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + i], a[o1 + i + bin[k - 1]]);
} else if(t == 2){
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + i], a[o2 + bin[k - 1] + i]);
bk = 0;
for(int i = 1; i < bin[k]; i++) if(a[o1 + i] - 1 != a[o1 + i - 1]) {bk = 1; break;}
for(int i = 1; i < bin[k]; i++) if(a[o2 + i] - 1 != a[o2 + i - 1]) {bk = 1; break;}
if(!bk) dfs(k + 1, s + 1);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + i], a[o2 + bin[k - 1] + i]);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + i], a[o2 + i]);
bk = 0;
for(int i = 1; i < bin[k]; i++) if(a[o1 + i] - 1 != a[o1 + i - 1]) {bk = 1; break;}
for(int i = 1; i < bin[k]; i++) if(a[o2 + i] - 1 != a[o2 + i - 1]) {bk = 1; break;}
if(!bk) dfs(k + 1, s + 1);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + i], a[o2 + i]);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + bin[k - 1] + i], a[o2 + i]);
bk = 0;
for(int i = 1; i < bin[k]; i++) if(a[o1 + i] - 1 != a[o1 + i - 1]) {bk = 1; break;}
for(int i = 1; i < bin[k]; i++) if(a[o2 + i] - 1 != a[o2 + i - 1]) {bk = 1; break;}
if(!bk) dfs(k + 1, s + 1);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + bin[k - 1] + i], a[o2 + i]);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + bin[k - 1] + i], a[o2 + bin[k - 1] + i]);
bk = 0;
for(int i = 1; i < bin[k]; i++) if(a[o1 + i] - 1 != a[o1 + i - 1]) {bk = 1; break;}
for(int i = 1; i < bin[k]; i++) if(a[o2 + i] - 1 != a[o2 + i - 1]) {bk = 1; break;}
if(!bk) dfs(k + 1, s + 1);
for(int i = 0; i < bin[k - 1]; i++) swap(a[o1 + bin[k - 1] + i], a[o2 + bin[k - 1] + i]);
} else dfs(k + 1, s);
}
int main() {
n = read();
jc[0] = 1; for(int i = 1; i <= n; i++) jc[i] = jc[i - 1] * i;
bin[0] = 1; for(int i = 1; i <= n; i++) bin[i] = bin[i - 1] * 2;
for(int i = 0; i < (1 << n); i++) a[i] = read();
dfs(1, 0);
printf("%lld\n", ans);
return 0;
}

本文探讨了一种特殊的排序问题,即通过有限的操作序列将1-2^N的排列从小到大排序,每种操作最多执行一次。文章提出了一种搜索算法,通过分析操作的顺序无关性和分段交换策略,来计算所有可能的不同操作序列数量。
2194





