Luogu P1118 Backward Digit Sums G/S

Backward Digit Sums G/S(DFS & 杨辉三角)

题目链接

前言：
又是一道USACO的题，他们的题一般来讲更重思维，对于编码的硬实力要求不是太高，一般来说，能想到正解，代码是很简洁的。

思路：

暴力解法:

看到这道题，先是想到了一个合理的暴力解法，求出一个1~n的全排列，对于每个全排列都按照题目的要求算出最后一行的值，但很显然，时间复杂度是很高的，光是全排列就有1e9的规模了，更不用说每次模拟的常数。

CODE：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define ll long long
#define INF 0x3f3f3f3f

using namespace std;
ll n,sum,a[20],f[20][20];
int main()
{
	ios::sync_with_stdio(false);
	cin >> n >> sum;
	for(int i = 1;i <= n;++i) a[i] = i;
	do
	{
		for(int i = 1;i <= n;++i)
		{
			f[1][i] = a[i];
			//cout << f[1][i] << " ";
		}
		//cout << endl;
		int i,j;
		for(i = 2;i <= n;++i)
		{
			for(j = 1;j <= n - i + 1;++j)
			{
				f[i][j] = f[i - 1][j] + f[i - 1][j + 1];
			}
		}
		if(f[n][1] == sum)
		{
 			for(int i = 1;i <= n;++i) cout << a[i] << " ";
 			cout << endl;
 			break;
		}
	}while(next_permutation(a + 1,a + 1 + n));//stl求全排列
	return 0;
}

所以，理所应当的只拿了7个点，3个点全部超时。

聪明的暴力解法

我们先来观察一下样例：
3 1 2 4
4 3 6
7 9
16

16 = $$3\ast 1+1\ast 3+2\ast 3+4\ast 1$$
有发现规律吗？

再来一组规模小一点的：

6 2 4
8 6
14

14 = $$6\ast 1+2\ast 2+4\ast 1$$

当原始序列长度为N时，最后一行的值为杨辉三角(从第1层开始计数)第N层上的每一个数乘上原始序列的每一个数的总和。

这样，我们就可以用$$O(Nlog(N))$$的时间预处理出杨辉三角1~N层，再套上dfs求序列的排列的模版，就是正解了。

CODE2：

#include<iostream>
#define ll long long
#define INF 0x3f3f3f3f

using namespace std;
ll f[20][20],n,sum,a[20];
bool b,v[20];
inline void dfs(ll,ll);
int main()
{
	ios::sync_with_stdio(false);
	cin >> n >> sum;
	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 - 1] + f[i - 1][j];
		}
	}
	dfs(1,0);
	return 0;
}

inline void dfs(ll p,ll now)
{
	if(now > sum||b) return ;//剪枝，当前搜到的值大于sum，就没必要再搜了。
	if(p == n + 1&&now == sum)
	{
		for(int i = 1;i <= n;++i) cout << a[i] << " ";
		b = true;
		return ;
	}
	
	for(int i = 1;i <= n;++i)
	{
		if(!v[i])
		{
			v[i] = true;
			a[p] = i;
			dfs(p + 1,now + i * f[n][p]);//第i个数乘上它所对应的权值
			v[i] = false;//回溯
		}
	}
}

这样的时间复杂度才是我们能接受的，所以这道题完全可以把数据再开大一点 。