背包问题

1.   0 1 背包问题：

#pragma GCC optimize("Ofast")
#include <iostream>
#include <algorithm>
#define Maxsize 100 + 1
using namespace std;
typedef long long ll;
struct node{
    int v;
    int w;
};
node arr[Maxsize];
ll dp[Maxsize][10000 + 1];
int main(){
    ios :: sync_with_stdio(false);
    cin.tie(0);  cout.tie(0);
    int n,capa;
    cin >> n >> capa;
    for(int i = 1; i <= n; i++)
        cin >> arr[i].w >> arr[i].v;

    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= capa; j++){
            if(arr[i].w <= j)dp[i][j] = max(dp[i-1][j],dp[i-1][j-arr[i].w] + arr[i].v);
            else dp[i][j] = dp[i-1][j];
            cout<<dp[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<dp[n][capa];
    return 0;
}

 * Input:
 * 3 6
 * 2 5
 * 3 8
 * 4 9
 *
 * Path:
 * 0 5 5 5 5 5
 * 0 5 8 8 13 13
 * 0 5 8 9 13 14
 *
 * Output:
 * 14

 *

 * 从填写dp数组的顺序可以看出, 每一次新填写的数组单元 , 只会利用到其左上方的单元所保存的结果

 * 转化到实际问题中理解就是 ： 当枚举到 前 i 个物品， 容量为 j 的状态时， 只会用到前 i - 1的状态和 前 j - wi 的状态

 * 而不会再用到 i-2 、i-3 的状态了, 同理, 下一次枚举 i + 1 个物品时， 也不会再用 i - 1 状态的结果

 * 也就是说，0 1 背包问题的每一个状态， 只与最近一次的外层循环的状态有关.

 * 因此可以利用滚动数组优化空间复杂度

 * 外层 for 循环 i 为 1 ~ n

 * 内层 for 循环 j 为 V ~ 1

 * 为什么 j 不是从 1 ～ V 呢 ？

 * 假如 j 从 1 ～ V,举个例子：

 * 我们先确定了 状态 dp[j-1] , 现在正在确定 dp[j]

 * 我们在一维数组中，是写成 dp[i][j] = dp[i-1][j]  或 dp[i-1][j-wi] + vi

 * 表示的是 ， dp[i][j] 是通过 前 i-1个物品的状态推导得到的

 * 然而我们的 1维dp，会通过用 i 来覆盖 i-1状态, 假如正着遍历 j , 那么会首先将 [i-1][....] 的状态先覆盖成为 [i][...], 再用覆盖后的状态来得到 dp[i][j]

 * 那么就会导致原本的 dp[i-1][j-wi] + vi 变成了 dp[i][j-wi] , 也就是通过 i 个物品， j-wi 个容量推导得到了 前 i 个物品， j 个容量的状态

 * 这显然是错误的.

 

用滚动数组优化空间复杂度：

#pragma GCC optimize("Ofast")
#include <iostream>
using namespace std;
struct node{
    int w;
    int v;
};
node arr[101];
int dp[1000];
int main(){
    int n,V;
    cin >> n >> V;
    for(int i = 1; i <= n; i++)
        cin >> arr[i].w >> arr[i].v;
    
    for(int i = 1; i <= n; i++)
        for(int j = V; j >= arr[i].w; j--)
            dp[j] = max(dp[j],dp[j-arr[i].w] + arr[i].v);
    return 0;
}

 

2. 完全背包问题：

 

考虑到在对 0 1 背包用滚动数组优化的时候，之所以要求容量 j 必须倒着遍历，就是为了保证在枚举状态 dp[i][j] 时所使用的状态是还没有被 dp[i][j-?] 覆盖的状态（也即dp[i-1][j-??]）

而完全背包恰好就要求每一个物品可以多次使用。 那么，在推导 dp[i][j] 时， 其最优解可能就是由 dp[i][j-??] 推导得到的。

所以，解完全背包问题，只需要将01背包的滚动数组优化的解法中j正着遍历就可以了。

完全背包
#pragma GCC optimize("Ofast")
#include <iostream>
using namespace std;
struct node{
    int w;
    int v;
};
node arr[100];
int dp[10000];  // 不少于最大容量
int main(){
    int n,V;
    cin >> n >> V;
    for(int i = 1; i <= n; i++)
        cin >> arr[i].w >> arr[i].v;
    for(int i = 1; i <= n; i++)
         for(int j = arr[i].w; j <= n; j++)
                 dp[j] = max(dp[j],dp[j-arr[i].w] + arr[i].v);

     cout<<dp[V];
     return 0;
}

 

3.多重背包： 三种解法 , 单调队列的解法最优 ， 不过还没完全弄懂 ， 等以后弄懂了再写详细注释。现在先记模版。

/*
 * 多重背包问题的三种解法
 *
 */
#include <iostream>
#include <vector>
#include <queue>
#define Maxsize 100
using namespace std;
void solution1(){  // 最朴素、无优化
    struct node{
        int w;
        int v;
        int num;
    };
    int n,v;
    node arr[Maxsize];
    int dp[Maxsize];
    cin >> n >> v;
    for(int i = 1; i <= n; i++)
        cin >> arr[i].w >> arr[i].v >> arr[i].num;
    
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= arr[i].num; j++){
            for(int p = v; p >= j*arr[i].w; p--){
                dp[p] = max(dp[p],dp[p-j*arr[i].w]+j*arr[i].v);
            }
        }
    }
    
    // 状态转移方程
    // dp[i][j] = max(dp[i-1][j-k*arr[i].w] + k*arr[i].v)    { 其中 0 <= k <= arr[i].num 且  k*arr[i].w <= p }
    cout<<dp[v];
}
void solution2(){ // 二进制优化
    struct node{
        int w;
        int v;
    };
    int n,v;
    vector<node> vec;
    int dp[Maxsize];
    cin >> n >> v;
    int now_w,now_v,now_num;
    for(int i = 0; i < n; i++){
        int base = 1;
        cin >> now_w >> now_v >> now_num;
        int sum = 0;
        while(base * now_w <= v && sum + base <= now_num){
            node New;   New.w = base * now_w;   New.v = base * now_v;
            vec.push_back(New);
            sum += base;
            base <<= 1;
        }
        if(sum != now_num && (now_num - sum)*now_w <= v){
            node New;   New.w = (now_num - sum) * now_w;   New.v = (now_num - sum) * now_v;
            vec.push_back(New);
        }
    }
    
    int s = (int)vec.size();
    for(int i = 0; i < s; i++){ // 注意从0开始读入
        for(int j = v; j >= vec[i].w; j--){
            dp[j] = max(dp[j],dp[j-vec[i].w] + vec[i].v);
        }
    }
    cout<<dp[v];
    // 状态转移方程
    // dp[j] = max(dp[j],dp[j-k*arr[i].w] + k*arr[i].v)    { 其中 0 <= k <= arr[i].num 且  k*arr[i].w <= p }
}
void solution3(){
    struct node{
        int f;
        int id;
    };
    int dp[20000];
    int n,v;
    cin >> n >> v;
    int now_w,now_v,now_num;
    for(int i = 1; i <= n; i++){  // 枚举物品
        cin >> now_w >> now_v >> now_num;
        now_num = min(now_num,v/now_w); // 这个物品所能选择的数量 , 需满足不大于背包体积 , 这个 now_num 就是我们的区间大小
        for(int j = 0; j < now_w; j++){ // 枚举当前余数
            deque<node> dq;
             // 由solution2 可以知道, dp[j] 的子问题只包含了 dp[j-k*arr[i].w] , 也就是说,它们是关于 arr[i].w 同余的
             // 将各个状态按照对 w 取模所得余数进行分类
             // 那么只有同一类的状态可以相互影响, 不同类的状态无法相互影响
            for(int k = 0; k * now_w + j <= v; k++){
                node New;
                New.f = dp[k*now_w+j] - k*now_v;
                New.id = k;
                while(not dq.empty() and dq.back().f < New.f)
                    dq.pop_back();
                
                dq.push_back(New);
                dp[k*now_w+j] = dq.front().f + k*now_v;
                if(not dq.empty() and New.id -dq.front().id == now_num)
                    dq.pop_front();
            }
        }
    }
    cout<<dp[v];
}
int main(){
    solution3();
    return 0;
}