多重部分和问题

问题描述

有n中不同大小的数字ai，每种mi个。判断是否可以从这些数字之中选出若干个使它们的和恰好为K

限制条件

1 <= n <= 100

1 <= ai, mi, <= 100000

1 <= K <= 100000

方式一

定义bool　　dp[i+1][j] 前i个数(含)能否加和为 j

那么状态转移方程 

//存在性问题 所以是取或

for (int k = 0; k*a[i] <= j && k <= m[i]; k++)

dp[i+1][j] |=  dp[i][j-k*a[i]];

这样程序的复杂度是O(K∑mi), 并且 bool dp 的信息有点浪费

 

方式二

定义dp[i+1][j] 前i+1个数加和得到j时 第i个数 能剩余多少个(没有时 为-1)

那么状态转移方程

dp[i+1][j] =

{

　　-1 　　　　(a[i] > j || dp[i+1][j-a[i]] <= 0) //大于j或者已经没有了

　　m[i]　　　(dp[i][j] >= 0) //前i-1个数已经到达j 那么不需要消耗第i个数　　　　　

　　dp[i+1][j-a[i]] - 1 (其他)

}

这样复杂度O(nK)

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;


int n, K;
int a[128], m[128];
bool dp[128][100007];
int dp3[128][100007];
int main()
{
    freopen("in.txt", "r", stdin);
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
    {
        scanf("%d%d", &a[i], &m[i]);
    }
    scanf("%d", &K);
    //做法一 定义bool dp[i][j]: 前i个数能否 构成和为j
    //状态转移方程 : dp[i+1][j] = dp[i][j-k*a[i]]  0 <= k <= m[i]
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j <= K; j++)
        {
            for (int k = 0; k <= m[i]; k++)
            {
                if (j >= k*a[i])
                {
                    dp[i+1][j] |= dp[i][j-k*a[i]];
                }
            }
        }
    }
    if (dp[n][K]) cout << "yes" << endl;
    else cout << "no" << endl;
    //DP求取bool结果浪费不少    复杂度O(K∑imi)

    //方式二 定义dp[i+1][j] 前i个数 加和为j时 第i个数剩下的个数
    //状态转移方程
    //dp[i+1][j] = m[i] (dp[i][j] >= 0)
    //           = -1   (j < a[i] || dp[i+1][j-a[i]] < 0
    //           = d[i+1][j-a[i]] - 1   其他

    //重复利用数组,
    int dp1[128];
    memset(dp1, -1, sizeof(dp1));
    dp1[0] = 0;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j <= K; j++)
        {
            if (dp1[j] >= 0)
            {
                dp1[j] = m[i];
            }
            else if(j < a[i] || dp1[j-a[i]] <= 0)
            {
                dp1[j] = -1;
            }
            else
            {
                dp1[j] = dp1[j-a[i]]-1;
            }
        }
    }
    if (dp1[K] >= 0) cout << "yes" << endl;
    else cout << "no" << endl;

    //不重复利用数组
    memset(dp3, 0, sizeof(dp3));
    dp3[0][0] = 0;
    for (int i = 0;i < n; i++)
    {
        for (int j = 0; j <= K; j++)
        {
            if (dp[i][j] >= 0) dp[i+1][j] = m[i];
            else if (j < a[i] || dp3[i+1][j-a[i]] <= 0) dp[i+1][j] = -1;
            else dp[i+1][j] = dp[i+1][j-a[i]] - 1;
        }
    }
    if (dp3[n][K] >= 0) cout << "yes" << endl;
    else cout << "no" << endl;
}