2019年蓝桥杯C++B组决赛B题

2019年蓝桥杯C++B组决赛B题

2019可以被分解成若干个两两不同的素数，请问不同的分解方案有多少种？
注意：分解方案不考虑顺序，如2+2017=2019和2017+2=2019属于同一种方案。

这里给出两种解决方案：
方案一：
这个题目描述如此简便。。
暴力超时。用记忆化搜索或者dp均可以。
解题思路：欧拉线性筛法出素数。这个地方注意一下边界范围的时候，把素数放进数组的时候的边界判断。一不小心就会出错。所以素数筛的时候尽可能扩大范围。
比如当前范围是2019，素数筛到3000即可。

然后dp求解。
dp[i][j]表示数i分解成最大素数为j的时候的方案数。
这里的j用存储素数的数组表示即可。
状态转移方程。
dp[i][j] = sum(dp[i - j][k]);
其中k也为素数，代码部分用数组代替。
判断条件的时候：由于题目说的2+2017=2019和2017+2=2019属于同一种方案。
我们就把大的素数放在前面，小的放在后面，严格递减就不会重复累加。
初始化将dp[i][i] = 1;其中i为素数。
因为严格递减。我们循环到成立的位置时是符合要求的分解。那么我们需要加上当前方案数。
最后ans累加一下就可以啦。
注意ans和dp均为ll类型。

方案二：这实际上就是一道0-1背包问题。
dp[i][j]表示前i个数背包容量为j时的方案数（背包容量为j那么就表示组成的和是j）
首先用埃筛把素数给筛选出来
状态转移方程：
无非是装或不装的问题：
对于不装：
那就是从前i - 1个数的状态转移过来：
dp[i][j] = dp[i - 1][j]:代表前i - 1个数和为j的方案数。
如果要把第i个数装进去的话：
如果此时j >= prim[i]的话，那么就可以把prim[i]加进来,是从前i - 1个数的状态转移过来的，累加求和：
dp[i][j] += dp[i - 1][j - prim[i]];
代表前i - 1个数组成和为j - prim[i]的方案数
最后输出即可
dp[][]开long long类型

答案是：

代码一部分：

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;

vector<int> v;
int vis[100000];
ll dp[2020][2020];

void prime()
{
	for (int i = 2; i <= 3000; i++)
	{
		if (!vis[i])
		{
			v.push_back(i);
			for (int j = i + i; j <= 3000; j += i)
			{
				vis[j] = 1;
			}
		}
	}
}

int main()
{
	prime();
	for (int i = 0; v[i] <= 2019; i++)
	{
		dp[v[i]][v[i]] = 1;
	}
	for (int i = 2; i <= 2019; i++)
	{
		for (int j = 0; v[j] <= i; j++)
		{
			for (int k = 0; k < j && v[k] <= i - v[j]; k++)
			{
				dp[i][v[j]] += dp[i - v[j]][v[k]];
			}
		}
	}
	ll ans = 0;
	for (int i = 0; v[i] <= 2019; i++)
	{
		ans += dp[2019][v[i]];
	}
	cout << ans;
	return 0;
} 

代码二部分：

#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 10;
typedef long long ll;

int prim[N];
int vis[N];
int n = 1;
ll dp[N][N];

void init()
{
	for (int i = 2; i <= 2019; i++)
	{
		if (!vis[i])
		{
			prim[n++] = i;
			for (int j = i + i; j <= 2019; j += i)
			{
				vis[j] = 1;
			}
		}
	}
}

int main()
{
	init();
	dp[0][0] = 1;
	for (int i = 1; i < n; i++)
	{
		for (int j = 0; j <= 2019; j++)
		{
			dp[i][j] = dp[i - 1][j];
			if (prim[i] <= j)
			{
				dp[i][j] += dp[i - 1][j - prim[i]];
			}
		}
	}
	cout << dp[n - 1][2019] << endl;
	return 0;
}