从01背包开始动态规划：暴力解法 + dp + 滚动数组 + dp优化_有限背包dp优化

    01背包问题是动态规划中最经典的问题之一，本篇将通过给出其四种解法，使读者更深刻理解动态规划。

  有N件物品和一个容量是 V 的背包，每个物品有各自的体积和价值，且每个物品只能放一次（这也是01背包名字的由来），如何让背包里装入的物品具有最大的价值总和？

目录

方法一：暴力dfs：

方法二：dp

方法三：滚动数组

方法四：dp优化，用一个数组存储

方法一：暴力dfs：

#include<iostream>
#include<cmath>
using namespace std;
 
int n, V;
const int N = 1010;
int w[N];
int v[N];
int res = 0;
 
void dfs(int index, int sumV, int sumW) {
    if (index == n) {
        if (sumW > res && sumV <= V) {
            res = sumW;
        }
        return;
    }
    if (sumV > V) return;
 
    dfs(index + 1, sumV, sumW); //不选
    dfs(index + 1, sumV + v[index], sumW + w[index]); //选
}
 
int main() {
    cin >> n >> V;
    for (int i = 0; i < n; i++) {
        cin >> v[i] >> w[i];
    }
 
    dfs(0, 0, 0);
    cout << res;
    return 0;
}

方法二：dp

  用一个二维数组来存储dfs的递归搜索树的过程，f [ i ] [ j ] 表示在选到第 i 个物品，背包剩余体积为 j 时，最大的总价值 

  对每一种物品，都有选和不选两个选项，在 j > v [ i ] 时，说明背包能放下当前第 i 个物品

• 不选时，f [ i ] [ j ] 不变
• 选：f [ i ] [ j ] = f [ i ] [ j - v [ i ] + w [ i ] 

取 max （选，不选）作为结果。

#include<iostream>
#include<cmath>
using namespace std;
 
int n,V;
const int N = 1010;
int w[N];
int v[N];
int f[N][N];
 
int main(){
    cin >> n >> V;
    for(int i = 1;i <= n;i++){
        cin >> v[i] >>  w[i];
    }
    
    for(int i = 1;i <= n;i++){
        for(int j = 0;j <= V;j++){
            f[i][j] = f[i - 1][j];
            if(j >= v[i])
                f[i][j] = max(f[i][j],f[i - 1][j - v[i]] + w[i]);
        }
    }
    
    cout << f[n][V];
 
    return 0;
}

方法三：滚动数组

  滚动数组，就是将一个二维数组以动态的方式存储的过程，在二维数组产生的过程中，用一个一维数组存储当前这一行的数。

  本题用两个数组来存储，其中 f 在更新前（memcpy(f , g , sizeof f)）表示第 i - 1层的数，而 g 表示第i层的数，每一层完成后，对 f 进行更新

#include<iostream>
#include<cmath>
#include<cstring>
using namespace std;
 
int n,V;
const int N = 1010;
int w[N];
int v[N];
int f[N];
int g[N];
 
int main(){
    cin >> n >> V;
    for(int i = 1;i <= n;i++){
        cin >> v[i] >>  w[i];
    }
    
    for(int i = 1;i <= n;i++){
        for(int j = 0;j <= V;j++){
            if(j >= v[i]) {
                g[j] = max(f[j],f[j - v[i]] + w[i]);
            }
        }
        memcpy(f,g,sizeof f);
    }
    
    printf("%d",f[V]);
    return 0;
}

方法四：dp优化，用一个数组存储

  对滚动数组的思想进行优化，如何只用一个一维数组存储呢？如何直接将滚动数组的g删去，会导致 f 的更新错误，因为在更新 f [ j ] 时，f [ j - v [ i ] ] 已经更新过，也就是他在第 i 层，而更新时需要的是第 i - 1 层的数据，如下图：（下两图来源于b站up，一只会code的小金鱼）

  因此需要将 j 的遍历从后往前走，这样就可以保证 f [ j - v [ i ] ] 没有被更新过 

#include<iostream>
#include<cmath>
#include<cstring>
using namespace std;
 
int n,V;
const int N = 1010;
int w[N];
int v[N];
int f[N];
 
int main(){
    cin >> n >> V;
    for(int i = 1;i <= n;i++){
        cin >> v[i] >>  w[i];
    }
    
    for(int i = 1;i <= n;i++){
        for(int j = V;j >= 0 ;j--){
            if(j >= v[i]) {
                f[j] = max(f[j],f[j - v[i]] + w[i]);
            }
        }
    }
    
    printf("%d",f[V]);
    return 0;
}

以上是本文全部内容，如果对你有帮助点个赞再走吧~  ₍˄·͈༝·͈˄*₎◞ ̑̑