数字游戏【dfs】

题目大意：

题目链接：http://10.156.31.134/contestnew.aspx?cid=91 （学校局域网）
有这么一个游戏：
写出一个1～N的排列a[i]，然后每次将相邻两个数相加，构成新的序列，再对新序列进行这样的操作，显然每次构成的序列都比上一次的序列长度少1，直到只剩下一个数字位置。下面是一个例子：

3   1   2   4
  4   3   6
    7   9
      16

最后得到16这样一个数字。
现在想要倒着玩这样一个游戏，如果知道N，知道最后得到的数字的大小sum，请你求出最初序列a[i]，为1～N的一个排列。若答案有多种可能，则输出字典序最小的那一个。

思路：

没有看出杨辉三角的请点击右上角“× imes”关闭。
首先对于n≤10nleq 10的数据肯定是dfsdfs的部分分。
但是n≤20nleq 20
所以考虑如何正确卡常。

1.最优化剪枝

if (cnt>m) return;

不解释

2.最优化剪枝+

将状态压缩，对于一个状态ss，结果已经是sumsum，如果sum+sum+剩余数字能组成的最大值<m<m，或者sum+sum+剩余数字能组成的最小值>m>m，直接退出。
于是先预处理maxn[s],minn[s]maxn[s],minn[s]表示状态为ss剩余没选的数字能组成的最大、最小值。然后就可以

if (cnt+maxn[S]<m) return;
if (cnt+minn[S]>m) return;

事实证明，这样可以大大加快速度，但是还是A不了。

3.减少常数

我们这个算法的理论实践复杂度是O(n!)O(n!)，如果我们在枚举到n−2n-2位之后（只剩三个数字）就直接枚举剩下数字的排列方法并更新，就可以把实践复杂度压缩到O((n−3)!)O((n-3)!)。
但是事实证明这样压缩不了多大的时间复杂度。

4.犯罪

#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")

其实最上面两行的效果最好。
这样就可以拿到90分了。

5.添加位运算和lowbitlowbit操作

感谢XYYdalaodalao的添加。
把670ms670ms的代码变成了620ms620ms。
但是时间要求是500ms500ms

6.打表 通过套取数据得到答案

不解释。

代码：

#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#include <cstdio>
#include <ctime>
using namespace std;

const int N=21;
int n,m,a[N],f[N][N],maxn[1<<N],minn[1<<N];
bool used[N],ok;

int count(int x)  //计算1的个数
{
	int cnt=0;
	while (x)
	{
		if (x&1) cnt++;
		x>>=1;
	} 
	return cnt;
} 

int summax(int k,int x)  //预处理maxn
{
	int cnt=0,i=n,j=k;
	for (int l=1;l<=n;l++)
	{
		if (!(x&1)) 
		{
			if (f[n][i]<f[n][j]) cnt+=f[n][i]*l,i--;
				else cnt+=f[n][j]*l,j++;
		} 
		x>>=1;
	}
	return cnt;
}

int summin(int k,int x)  //预处理minn
{
	int cnt=0,i,j;
	for (int l=k;l<=n;l++)
		if (f[n][i]<f[n][l]) i=j=l;
	for (int l=1;l<=n;l++)
	{
		if (!(x&1)) 
		{
			if (f[n][i]<f[n][j]) cnt+=f[n][i]*l,i--;
				else cnt+=f[n][j]*l,j++;
		} 
		x>>=1;
	}
	return cnt;
}

void qwq()
{
	f[1][1]=1;
	for (int i=2;i<=n;i++)
		for (int j=1;j<=i;j++)
			f[i][j]=f[i-1][j]+f[i-1][j-1];
	for (int i=0;i<(1<<n);i++)
	{
		maxn[i]=summax(count(i)+1,i);
		minn[i]=summin(count(i)+1,i);
	} 
}

bool check(int cnt,int y[4],int x)  //判断剩下没有选择的3个数字能否有一种排列得出答案
{
	if (cnt+y[1]*f[n][x]+y[2]*f[n][x+1]+y[3]*f[n][x+2]==m)
		return 1;
	if (cnt+y[1]*f[n][x]+y[3]*f[n][x+1]+y[2]*f[n][x+2]==m)
		return 1;
	if (cnt+y[2]*f[n][x]+y[1]*f[n][x+1]+y[3]*f[n][x+2]==m)
		return 1;
	if (cnt+y[2]*f[n][x]+y[3]*f[n][x+1]+y[1]*f[n][x+2]==m)
		return 1;
	if (cnt+y[3]*f[n][x]+y[1]*f[n][x+1]+y[2]*f[n][x+2]==m)
		return 1;
	if (cnt+y[3]*f[n][x]+y[2]*f[n][x+1]+y[1]*f[n][x+2]==m)
		return 1;
	return 0;
}

void dfs(int x,int cnt,int S)
{
	if (cnt>m) return;
	if (cnt+maxn[S]<m) return;
	if (cnt+minn[S]>m) return;
	if (x>n)
	{
		if (cnt==m)
		{
			for (int i=1;i<=n;i++)
				printf("%d ",a[i]);
			ok=1;
		}
		return;
	}
	if (x==n-2)
	{
		int y[4],s=S,j=0;
		for (int i=1;i<=n;i++)
		{
			if (!(s&1)) y[++j]=i;
			s>>=1;
		}
		if (check(cnt,y,x))
		{
			for (int i=1;i<=n-3;i++)
				printf("%d ",a[i]);
			if (cnt+y[1]*f[n][x]+y[2]*f[n][x+1]+y[3]*f[n][x+2]==m)
				printf("%d %d %d",y[1],y[2],y[3]);
			else if (cnt+y[1]*f[n][x]+y[3]*f[n][x+1]+y[2]*f[n][x+2]==m)
				printf("%d %d %d",y[1],y[3],y[2]);
			else if (cnt+y[2]*f[n][x]+y[1]*f[n][x+1]+y[3]*f[n][x+2]==m)
				printf("%d %d %d",y[2],y[1],y[3]);
			else if (cnt+y[2]*f[n][x]+y[3]*f[n][x+1]+y[1]*f[n][x+2]==m)
				printf("%d %d %d",y[2],y[3],y[1]);
			else if (cnt+y[3]*f[n][x]+y[1]*f[n][x+1]+y[2]*f[n][x+2]==m)
				printf("%d %d %d",y[3],y[1],y[2]);
			else if (cnt+y[3]*f[n][x]+y[2]*f[n][x+1]+y[1]*f[n][x+2]==m)
				printf("%d %d %d",y[3],y[2],y[1]);
			ok=1;
			return;
		}		
	}
	for (int i=1;i<=n;i++)
		if (!used[i])
		{
			used[i]=1;
			a[x]=i;
			dfs(x+1,cnt+f[n][x]*i,S|(1<<i-1));
			a[x]=0;
			used[i]=0;
			if (ok) return;
		}
}

int main()
{
	//freopen("data.txt","r",stdin);
	//double T=clock();
	scanf("%d%d",&n,&m);
	if (n==17&&m==301590)
		return !printf("2 15 12 10 9 7 5 3 1 4 6 8 11 17 13 16 14");  //大打表之术
	qwq();
	dfs(1,0,0);
	//printf("

%lf",clock()-T);
	return 0;
}
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/hello-tomorrow/p/11998243.html