LINK：Permutation

对于这种构造神题 我自然是要补的。为啥就我没想出来哇.

30分还是很好写的 注意8!实际上很小 不需要爆搜 写bfs记录状态即可。至于判断状态是否出现与否 可以开map np一点的做法是利用康拓展开和逆康托展开(还需要hash 没啥用.

但是 经过不断的手玩排列为8的数列容易发现 对于最差的情况 8 7 6 5 4 3 2 1 也最多需要3次。

所以 可以直接去掉bfs的过程 直接三层2^n枚举 开map统计状态量 这样可以做的飞快。算法的名称估计可以叫做为 模拟bfs.

const int MAXN=41000;
int n,T;
int ans;
int a[MAXN],ans1,ans2,ans3;
int s1[MAXN],s2[MAXN],s3[MAXN],p[MAXN],pre2[MAXN],pre3[MAXN];
map<int,int>H[4];
inline void put_(int x,char c){printf("%d%c",x,c);}
inline void put1()
{
	put(ans);
	if(T)
	{
		rep(1,n,i)put_(a[i],i==n?'\n':' ');
		if(ans1)rep(1,n,i)put_(s1[ans1]/p[i]%10,i==n?'\n':' ');
		if(ans2)rep(1,n,i)put_(s2[ans2]/p[i]%10,i==n?'\n':' ');
		if(ans3)rep(1,n,i)put_(s3[ans3]/p[i]%10,i==n?'\n':' ');
		return;
	}
}
int main()
{
	//freopen("1.in","r",stdin);
	get(n);get(T);
	int ss=0,ww=0;p[n]=1;
	rep(1,n,i)get(a[i]),ss=ss*10+a[i];
	rep(1,n,i)ww=ww*10+i;
	fep(n-1,1,i)p[i]=p[i+1]*10;
	if(ss==ww){put1();return 0;}
	if(n<=8)
	{
		int maxx=(1<<n)-1;
		int id1=0;++ans;
		rep(1,maxx,i)
		{
			int w1=0,w2=0,cnt2=0;
			rep(1,n,j)
			{
				int cc=ss/p[j]%10;
				if(i&(1<<(j-1)))w2=w2*10+cc,++cnt2;
				else w1=w1*10+cc;
			}
			w1=w1*p[n-cnt2]+w2;
			s1[++id1]=w1;H[1][w1]=1;
			if(w1==ww){ans1=id1;put1();return 0;}
		}
		int id2=0;++ans;
		rep(1,maxx,i)
		{
			rep(1,id1,k)
			{
				int w1=0,w2=0,cnt2=0;
				rep(1,n,j)
				{
					int cc=s1[k]/p[j]%10;
					if(i&(1<<(j-1)))w2=w2*10+cc,++cnt2;
					else w1=w1*10+cc;
				}
				w1=w1*p[n-cnt2]+w2;
				if(H[1].find(w1)!=H[1].end()||H[2].find(w1)!=H[2].end())continue;
				s2[++id2]=w1;pre2[id2]=k;H[2][w1]=1;if(w1==ww){ans2=id2;ans1=pre2[id2];put1();return 0;}
			}
		}
		int id3=0;++ans;
		rep(1,maxx,i)
		{
			rep(1,id2,k)
			{
				int w1=0,w2=0,cnt2=0;
				rep(1,n,j)
				{
					int cc=s2[k]/p[j]%10;
					if(i&(1<<(j-1)))w2=w2*10+cc,++cnt2;
					else w1=w1*10+cc;
				}
				w1=w1*p[n-cnt2]+w2;
				if(H[1].find(w1)!=H[1].end()||H[2].find(w1)!=H[2].end()||H[3].find(w1)!=H[3].end())continue;
				s3[++id3]=w1;pre3[id3]=k;H[3][w1]=1;
				if(w1==ww)
				{ans2=pre3[id3];ans1=pre2[ans2];ans3=id3;put1();return 0;}
			}
		}
	}
	return 0;
}

值得注意的是 代码写的过于繁琐 应该写一个函数调用三次 这样可以简便很多.

接下来是考虑正解：观察数据范围 其要求我们最多进行20次这样的操作。

这个下界类似于logn 如何确定下界：每一次都可以将两端进行合并 这样合并的条件两端是递增的 且第一段的最大值<第二段的最小值。

且这两端合并之后数值应该是连续的 不连续就没有意义。

基于数值连续这个思想我们可以设出一个q数组\(q_x\)表示x这个值所处位置。

每次合并两端数值相近的 如果有多段我们可以进行同时合并 所以最多此时为log段数上取整。

还有一种证明方法是 对于q数组 我们把这个数组划分若干段 每一段是连续的极长递增的段。

考虑任意两端 如果每次操作都相同那么他们一定还是无法进行合并 是不合法的。

所以对于任意两端 要求他们的操作序列是不相同的 所以要产生2^k种不同的操作序列才可以还原 答案仍然是logn.

至此 得到答案的下界之后 尝试构造。

构造也很容易了 因为我们知道每次只要合并两段即可 这样最多会合并logn次。

一种比较好写的写法 将每段划分奇偶 下标从0开始.

那么显然 奇数段放1偶数段放0 就可以将两端合并了 下次进行时容易发现下标可以直接/2算出 比暴力标号常数小一倍.

const int MAXN=50010;
int cnt,T,n;
int b[MAXN],a[MAXN],c[MAXN],ql[MAXN],qr[MAXN];
int main()
{
	freopen("1.in","r",stdin);
	get(n);get(T);
	rep(1,n,i)get(a[i]),b[a[i]]=i;
	rep(1,n,i)if(b[i]>b[i-1])c[i]=c[i-1];
	else c[i]=++cnt;
	int w=0;while((1<<w)<cnt+1)++w;
	put(w);
	if(!T)return 0;
	rep(1,n,i)put_(a[i]);puts("");
	rep(0,w-1,i)
	{
		int sl=0,sr=0;
		rep(1,n,j)if(!((c[a[j]]>>i)&1))ql[++sl]=a[j];
		else qr[++sr]=a[j];
		rep(1,sl,j)a[j]=ql[j];
		rep(1,sr,j)a[j+sl]=qr[j];
		rep(1,n,i)put_(a[i]);puts("");
	}
	return 0;
}