n个数求和方案的问题

给定一个有n个正整数的数组A和一个整数sum,求选择数组A中部分数字和为sum的方案数。
当两种选取方案有一个数字的下标不一样,我们就认为是不同的组成方案。

1、采用动态规划

F[i][j]的意义为从i个书中选取某些数使其和为j的方案的个数，

则F[i][j]=(j>=array[i])？（F[i-1][j-array[i]]+F[i-1][j]）:(F[i-1][j])。

初始条件对于所有的i，F[i][0]=1,相当于从i个数中都不选取，此时和为零。注意如果有溢出的话，二维数组定义需要为long long int 类型的。

代码如下：

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    int n;
    cin >> n;
    int sum;
    cin >> sum;
    int *array = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> array[i];
    }
     long long int **F = new long long int *[n + 1];
    for (int j = 0; j < n + 1; j++)
    {
        F[j] = new long long int[sum + 1];
        for (int k = 0; k<sum + 1; k++)
        {
            F[j][k] = 0;
        }
    }
    for (int i = 0; i <= n; i++)
    {
        F[i][0] = 1;
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j <= sum; j++)
        {
            if (j>=array[i - 1])
            {
                F[i][j] = F[i - 1][j - array[i - 1]] + F[i - 1][j];
            }
            else
            {
                F[i][j] = F[i - 1][j];
            }
        }
    }
    cout << F[n][sum] << endl;
}

2、采用递归方法。注意一下递归的终止条件，但是这种方案的花费时间较动态规划要多一些。

#include<iostream>
#include<vector>
using namespace std;
vector<int> Q;
int plan = 0;
void dfs(int num, int *array, int length)
{
    if (num == 0)
    {
        plan++;
        return;
    }
    if (num < 0 || length <= 0)
    {
        return;
    }
    Q.push_back(array[length - 1]);
    dfs(num - array[length - 1], array, length - 1);
    Q.pop_back();
    dfs(num, array, length - 1);
}
int main()
{
    int n;
    cin >> n;
    int sum;
    cin >> sum;
    int *array = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> array[i];
    }
    dfs(sum, array, n);
    cout << plan << endl;
}