专题-经典动态规划-CSDN博客

经典动态规划

(更新中...)

1．0-1背包

问题描述：给定num种物品和一个容量为c的背包，每种物品的体积是w，其价值为v，如何使选择装入背包内的物品，使得装入背包中的物品的总价值最大。其中，每种物品只有全部装入背包或不装入背包两种选择。

例：num=4 c=8

物品i　　体积w[i]　　价值V[i]

　　1　　　　3　　　　　　3

　　2　　　　3　　　　　　4

　　3　　　　4　　　　　　5

　　4　　　　5　　　　　　6

问题分析：对于每个物品有两种方法，能装下和不能装下

(1) 当前包的剩余容量小于该商品体积，装不下，状态转移方程为

dp[i][j]=dp[i-1][j] //其中i为第i个物品，j为背包当前剩余容量

(2) 当前背包的剩余容量大于该商品体积，能装下

dp[i][j]=max(dp[i-1][j], dp[i-1][j-w[i]]+v[i]) //在不装与装之间选择一个最优，dp[i-1][j-w[i]]+v[i]表示前i-1种物品中选取若干件物品放入剩余空间为j-w[i]的背包中所能得到的最大价值加上第i种物品v[i]；

状态转移方程，每一次推导dp[i][j]都是通过上一次循环保存下来的值dp[i-1][j-w[i]]来推导的，所以可以采用一维数组按从大到小扫描的顺序来实现状态方程。

状态转移表：

代码：

 1 #include <iostream>
 2 #include<algorithm>
 3 using namespace std;
 4 
 5 //建议定义一个较大数组，new的方式较为麻烦，还需要初始化边界条件
 6 int w[105], val[105],dp[105];  
 7 
 8 int main()
 9 {
10     int t, num;
11     cin >> num >> t;
12     for (int i = 1; i <= num; i++)
13         cin >> w[i] >> val[i];
14     for (int i = 1; i <= num; i++) {//物品 
15         for (int j = t; j>=w[i]; j--) //按递减顺序，以免提前覆盖上一次的值
16             dp[j] = max(dp[j - w[i]] + val[i], dp[j]);
17     }
18     cout << dp[t] << endl;
19     return 0;
20 }

2．完全背包

问题描述：有num种物品和一个容量为c的背包，每种物品不限数量。第i种物品体积是w[i]，价值是val[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

状态方程：dp[i][j]=max(dp[i-1][j-k*v[i]]+k*w[i], dp[i-1][j])

转化为0-1背包：dp[i][j]=max(dp[i-1][j-v[i]]+w[i], dp[i-1][j]) //和0-1背包的区别是，按递增顺序，覆盖上一次的值，即可以选取多个同一物品。转化为一维数组即是d[j]=max(d[j-v[i]]+w[i], d[j])

代码：

#include <iostream>
#include<algorithm>
using namespace std;

//建议定义一个较大数组，new的方式较为麻烦，还需要初始化边界条件
int w[105], val[105],dp[105];
int main()
{
    int t, num;
    cin >> num >> t;
    for (int i = 1; i <= num; i++)
    cin >> w[i] >> val[i];
    for (int i = 1; i <= num; i++) {//物品
        for (int j = w[i]; j <= t; j++) //按递增顺序，可以多次选择同一物品
            dp[j] = max(dp[j - w[i]] + val[i], dp[j]);
    }
    cout << dp[t] << endl;
    return 0;
}

3．多重背包

问题描述：有num种物品和一个容量为c的背包。第i种物品最多有n[i]件可用，每件体积是w[i]，价值是val[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

可以转化为o-1背包，在外层加一个数量限制即可，时间复杂度大而已

代码：

#include <iostream>
#include<algorithm>
using namespace std;

//建议定义一个较大数组，new的方式较为麻烦，还需要初始化边界条件
int w[105], val[105], n[105], dp[105];
int main()
{
    int t, num, res = -1;
    cin >> num >> t;
    for (int i = 1; i <= num; i++)
    cin >> w[i] >> val[i] >> n[i];
    for (int i = 1; i <= num; i++) {//物品
        for (int k = 0; k < n[i]; k++) {
            for (int j = t; j >= w[i]; j--) //按递减顺序，以免提前覆盖上一次的值
                dp[j] = max(dp[j - w[i]] + val[i], dp[j]);
        }
    }
    cout << dp[t] << endl;
    return 0;
}

问题分析：采用二进制思想优化，降低时间复杂度

将第i种物品分成若干件物品，可以有（w[i], val[i]）, （w[i]*2, val[i]*2）, （w[i]*4, val[i]*4）...例如n[i]=13,13可以分解为13=1+2+4+6（因为下一个数为8和超过了13，所以为13-1-2-4=6），可以发现0到13中任意一个数可以由1，2,4,6组合；同理18可以分解为18=1+2+4+8+3。因此将多重背包问题转化成了0-1为题。

代码：

#include <iostream>
#include<algorithm>
using namespace std;

//建议定义一个较大数组，new的方式较为麻烦，还需要初始化边界条件
int w[105], val[105], n[105], dp[105];
int biW[2000], biVal[2000];
int main()
{
    int t, num, res = -1;
    cin >> num >> t;
    int index = 0;
    //二进制思想优化，即n[i]的分解
    for (int i = 1; i <= num; i++) { 
        cin >> w[i] >> val[i] >> n[i];
        int b = 1;
        while (n[i] - b >= 0) {
            n[i] -= b;
            biW[++index] = b*w[i];
            biVal[index] = b*val[i];
            b *= 2;
        }
        biW[++index] = n[i] *w[i];
        biVal[index] = n[i] *val[i];
    }
    //转化为了0-1背包
    for (int i = 1; i <= index; i++) {//物品
        for (int j = t; j >= biW[i]; j--) //按递减顺序，以免提前覆盖上一次的值
        dp[j] = max(dp[j - biW[i]] + biVal[i], dp[j]);
    }
    cout << dp[t] << endl;
    return 0;
}