和为定值的子集数
题目描述
已知 n 个正整数，wi (1≤i≤n) 形成一个集合 W={w1,w2,...,wn}，集合中的元素彼此不相同。给定某个正整数 M ，集合W中可否存在子集，该子集的所有元素之和和恰好为M，问：这样的子集有多少个？
例如，4个正整数为：
11 13 24 7
若给定M=31，则有两个子集{7,11,13}和{7,24}
于是，这样的子集有 2 个。
关于输入
第1行，输入若干个正整数，表示集合的元素，各整数之间以空格间隔；
后面有多行，每行表示一个 M 值；若某行的 M 值为0，则结束。
关于输出
对应的每个有效的 M 值，输出相应行的子集数目
例子输入
11 13 24 7 31 24 45 55 0
例子输出
2 2 0 1
解题分析
这个问题可以使用动态规划（Dynamic Programming）来解决。动态规划是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。
在这个问题中，我们需要找到所有和为特定值 M 的子集的数量。我们可以使用一个二维动态规划数组 dp[i][j] 来存储到第 i 个元素为止，和为 j 的子集的数量。
这个问题的状态转移方程可以这样定义：
1. 如果当前集合的总和 M 为0，那么只有一个子集满足条件，即空子集，所以返回1。
2. 如果我们已经查看过所有的元素（i < 0），或者当前的总和 M 为负数，那么没有子集满足条件，返回0。
3. 如果当前元素 a[i] 大于当前的总和 M，那么我们不能包含这个元素，所以只能查看前 i-1 个元素，看看他们能否组成和为 M 的子集。所以 dp[i][M] = sum(i-1, M)。
4. 如果当前元素 a[i] 小于或等于当前的总和 M，那么我们有两种选择：包含这个元素或者不包含这个元素。所以 dp[i][M] = sum(i-1, M) + sum(i-1, M-a[i])。
在主函数中，我们首先使用一个循环来读取输入的元素，并将它们存储在数组 a 中。然后，我们使用另一个循环来读取输入的 M 值，并调用 sum 函数来计算满足条件的子集的数量。最后，我们将结果输出到屏幕上。
注意，为了提高效率，我们使用了记忆化搜索（也称为缓存）。我们使用一个二维数组 dp 来存储已经计算过的子问题的结果。在 sum 函数中，我们首先检查 dp[i][M] 是否已经被计算过。如果是，我们就直接返回它。否则，我们就计算它，然后将结果存储在 dp[i][M] 中，以便以后使用。
这种方法的时间复杂度是 O(n*M)，其中 n 是集合的元素数量，M 是目标和。空间复杂度也是 O(n*M)，用于存储 dp 数组。
代码实现
#include <iostream>
#include <cstring>
using namespace std;
int M, a[10000];
int len = 0;
int dp[10000][10000]={0};
int sum(int i, int M) {
if (M == 0) return 1;
if (i < 0 || M < 0) return 0;
if(dp[i][M]!=-1) return dp[i][M];
if (a[i] > M) {
dp[i][M]=sum(i-1,M);
return dp[i][M];
} else {
dp[i][M]=sum(i - 1, M) + sum(i - 1, M - a[i]);
return dp[i][M];
}
}
int main() {
char c;
memset(dp,-1,sizeof(dp));
while (cin >> a[len++]) {
c = getchar();
if (c == '\n') break;
}
while (cin >> M) {
if (M == 0) break;
cout << sum(len - 1, M) << endl;
}
return 0;
}
方法2:
解题分析2
这个问题可以使用动态规划来解决。我们可以构建一个二维数组dp，其中dp[i][j]表示使用前i个数字组成和为j的子集的数量。
初始条件是dp[i][0] = 1，表示使用前i个数字组成和为0的子集只有一种可能，即一个空集。然后我们可以根据以下状态转移方程来填充dp数组：
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i - 1]], 如果 j >= nums[i - 1]
dp[i][j] = dp[i - 1][j], 如果 j < nums[i - 1]
其中nums[i - 1]表示第i个数字。第一个条件表示我们可以选择包含第i个数字或者不包含第i个数字，第二个条件表示如果当前的和j小于第i个数字，那么我们不能选择第i个数字。文章来源：https://www.toymoban.com/news/detail-774101.html
这个算法的时间复杂度是O(n * M)，空间复杂度也是O(n * M)，其中n是集合中的数字数量，M是给定的目标和。文章来源地址https://www.toymoban.com/news/detail-774101.html
#include <iostream>
#include <cstring>
using namespace std;
int M, a[10000];
int len = 0;
int dp[10000][10000]={0};
int main() {
char c;
while (cin >> a[len++]) {
c = getchar();
if (c == '\n') break;
}
while (cin >> M) {
if (M == 0) break;
for(int i=0;i<len;i++){
dp[i][0]=1;
}
for(int i=0;i<len;i++){
for(int j=1;j<=M;j++){
if(i==0){
if(a[i]==j){
dp[i][j]=1;
}
continue;
}
if(a[i]>j){
dp[i][j]=dp[i-1][j];
}
else{
dp[i][j]=dp[i-1][j]+dp[i-1][j-a[i]];
}
}
}
cout<<dp[len-1][M]<<endl;
}
return 0;
}
到了这里，关于[递归，动态规划] 和为定值的子集合的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
