动态规划集合

cyy1104

已于 2022-12-15 11:31:09 修改

阅读量175

点赞数

分类专栏： C++ 文章标签：动态规划算法

于 2022-09-27 17:22:14 首次发布

本文链接：https://blog.csdn.net/cyy1104/article/details/127075009

版权

C++ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

①王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件	附件
电脑	打印机，扫描仪
书柜	图书
书桌	台灯，文具
工作椅	无

如果要买归类为附件的物品，必须先买该附件所属的主件，且每件物品只能购买一次。

每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。

王强查到了每件物品的价格（都是 10 元的整数倍），而他只有 N 元的预算。除此之外，他给每件物品规定了一个重要度，用整数 1 ~ 5 表示。他希望在花费不超过 N 元的前提下，使自己的满意度达到最大。

满意度是指所购买的每件物品的价格与重要度的乘积的总和，假设设第ii件物品的价格为v[i]v[i]，重要度为w[i]w[i]，共选中了kk件物品，编号依次为j_1,j_2,...,j_kj1,j2,...,jk，则满意度为：v[j_1]*w[j_1]+v[j_2]*w[j_2]+ … +v[j_k]*w[j_k]v[j1]∗w[j1]+v[j2]∗w[j2]+…+v[jk]∗w[jk]。（其中 * 为乘号）

请你帮助王强计算可获得的最大的满意度。

输入描述：

输入的第 1 行，为两个正整数N，m，用一个空格隔开：

（其中 N （ N<32000 ）表示总钱数， m （m <60 ）为可购买的物品的个数。）

从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q

（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）

输出描述：

输出一个正整数，为张强可以获得的最大的满意度。

示例1

输入：

复制输出：

复制

示例2

输入：

复制输出：

复制说明：

由第1行可知总钱数N为50以及希望购买的物品个数m为5；
第2和第3行的q为5，说明它们都是编号为5的物品的附件；
第4~6行的q都为0，说明它们都是主件，它们的编号依次为3~5；
所以物品的价格与重要度乘积的总和的最大值为10*1+20*3+20*3=130

//

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

int main() {
    int N, m;
    cin >> N >> m;
    // 由于价格是10的整数倍，处理一下以降低空间/时间复杂度
    //N = 10;
    vector<vector<int> > prices(61, vector<int>(3, 0));        // 价格
    vector<vector<int> > priceMultiplyPriority(61, vector<int>(3, 0));      // 重要程度
    for (int i = 1; i <= m; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        //a =a/10; 
        b *= a;
        if (c == 0) {
            prices[i][0] = a; priceMultiplyPriority[i][0] = b;
        }
        else {
            if (prices[c][1] == 0) {//表示输入了第一个附件
                prices[c][1] = a; priceMultiplyPriority[c][1] = b;
            }
            else {//表示输入了第二个附件，附件最多为2
                prices[c][2] = a; priceMultiplyPriority[c][2] = b;
            }
        }
    }
    // 使用分组背包
    vector<vector<int> > dp(m + 1, vector<int>(N + 1, 0));
    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= N; ++j) {
            //a是价格也就是主件占用的空间
            int a = prices[i][0], b = priceMultiplyPriority[i][0];
            //c是价格，也就是附件1占用的空间
            int c = prices[i][1], d = priceMultiplyPriority[i][1];
            //e是价格，也就是附件2占用的空间
            int e = prices[i][2], f = priceMultiplyPriority[i][2];
            //状态转移方程
            //j >= a不成立，则第i个不放入价值为dp[i - 1][j]
            //j >= a成立，则放入第i个物品，并且该物品是主件，dp[i - 1][j - a]前i-1个物品价值，空间为j - a
            //这句话可以改写成容易理解的0-1背包问题
            /*
                dp[i][j]=dp[i - 1][j];
                if(j>=a)
                {
                    dp[i][j]=max(dp[i-1][j-a]+b,d[i][j]);
                }
            */
            dp[i][j] = j >= a ? max(dp[i - 1][j - a] + b, dp[i - 1][j]) : dp[i - 1][j];
            //判断是否放入附件1
            dp[i][j] = j >= (a + c) ? max(dp[i - 1][j - a - c] + b + d, dp[i][j]) : dp[i][j];
            //判断是否放入附件2
            dp[i][j] = j >= (a + e) ? max(dp[i - 1][j - a - e] + b + f, dp[i][j]) : dp[i][j];
            //判断是否放入附件1、2
            dp[i][j] = j >= (a + c + e) ? max(dp[i - 1][j - a - c - e] + b + d + f, dp[i][j]) : dp[i][j];
        }
    }
    cout << dp[m][N] << endl;
}

// 64 位输出请用 printf("%lld")

②

现有n种砝码，重量互不相等，分别为 m1,m2,m3…mn ；
每种砝码对应的数量为 x1,x2,x3...xn 。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。

注：

称重重量包括 0

数据范围：每组输入数据满足 1 \le n \le 10 \1≤n≤10 ， 1 \le m_i \le 2000 \1≤mi≤2000 ， 1 \le x_i \le 10 \1≤xi≤10

输入描述：

对于每组测试数据：
第一行：n --- 砝码的种数(范围[1,10])
第二行：m1 m2 m3 ... mn --- 每种砝码的重量(范围[1,2000])
第三行：x1 x2 x3 .... xn --- 每种砝码对应的数量(范围[1,10])

输出描述：

利用给定的砝码可以称出的不同的重量数

示例1

输入：

2
1 2
2 1

复制输出：

复制说明：

可以表示出0，1，2，3，4五种重量。

#include <iostream>
#include <vector>
#include <set>
using namespace std;

int main() {
    int a[10],num,temp;
    while(cin>>num){

        vector<int> res;
        for( int i = 0 ; i < num ; i++){
            cin>>a[i];
        }

        for( int i = 0 ; i < num ; i++){
            cin>>temp;
            for(int j = 0 ; j < temp ; j ++) res.push_back(a[i]);
        }

        set<int> fres;
        fres.insert(0);

        for(int i = 0 ; i < res.size() ; i++){

            set<int> tmp(fres);
            for(set<int>::iterator it = tmp.begin(); it != tmp.end() ; it++){
                fres.insert(*it + res[i]);
            }

        }

        cout<<fres.size()<<endl;

    }

}

实际上这个问题的动态过程我们是可以理解的，但是一开始很难用代码表达出这么清晰的逻辑，加入说初始的列表为：

5
1 2 3 4 5
2 1 3 1 2

那么其实我们可以给他初始化成 1 1 2 3 3 3 4 5 5

也就是初始矩阵的第一行位：

0 1 2 3 4 5

然后我们再考虑到重量为1的数目为2，所以可以在之前的重量上加1，就会生成

0 1 2 3 4 5 + 0+1 1+1 2+1 3+1 4+1 5+1
//因为是set，会过滤掉重复的数字，则会变成0 1 2 3 4 5 6
//那么下一次行列式初始化为0 1 2 3 4 5 6
//再因为重量为2的砝码只有一个，所以来到3
0 1 2 3 4 5 6 + 0+3 1+3 2+3 3+3 4+3 5+3 6+3
//之后行列式初始化为0 1 2 3 4 5 6 7 8 9