专题-经典动态规划

经典动态规划

(更新中...)

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]]来推导的，所以可以采用一维数组按从大到小扫描的顺序来实现状态方程。

状态转移表：

 

代码：

#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 = t; j>=w[i]; j--) //按递减顺序，以免提前覆盖上一次的值
            dp[j] = max(dp[j - w[i]] + val[i], dp[j]);
    }
    cout << dp[t] << endl;
    return 0;
}

 

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;
}

 

4．击鼓传花

问题描述：n个同学坐着围成一个圆圈，指定一个同学（小赛）手里拿着一束花，主持人在旁边背对着大家开始击鼓，鼓声开始之后拿着花的同学开始传花，每个同学都可以把花传给自己左右的两个同学中的一个（左右任意），有多少种不同的方法可以使得从小赛手里开始传的花，传了m次以后，又回到小赛手里。（3<=n<=30，1<=m<=30）

问题分析：

n个人围成的是一个循环体（编号0-（n-1）），每次都只能往左或者右传花，定义dp[i][j]为j号编号人员能够在i次传递次数中传递到起点位置次数。

状态转移方程:dp[i][j]=dp[i-1][j-1]+dp[i-1][j+1]

初始条件：dp[1][1]=1;  dp[1][n-1]=1;   dp[0][0]=1;

代码：

int dph(int  n, int m){
    int dp[31][31];
    dp[1][1]=1;
    dp[1][n-1]=1;
    dp[0][0]=1；
    for(int i=2; i<=m; i++){
        for(int j=0; j<n; j++){
            dp[i][j]=dp[i-1][(n+j-1)%n]+dp[i-1][(j+1)%n];
        }
    }
    return dp[m][0];
}

int main(){
    int n,m;
    cin>>n>>m;
    int result=dph(n, m);
    cout<<result<<endl;
    return 0;
}