动态规划之0-1背包问题

动态规划之0-1背包问题

文章目录

• • 动态规划之0-1背包问题
  • • 一、先给出代码
    • 二、讲解
    • • 第一步：初始化
      • 第二步：动态规划，填表
      • 第三步：回溯，找到选择方案
      • 总结
    • 三、进阶（用一维数组解决问题）

---

一、先给出代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void Bp(vector<int >&weights, vector<int> &values, vector<vector<int>>& dp,int bag_weight,vector<int>&result)
{
	//初始化
	for (int j = weights[0]; j <= bag_weight; j++) {
		dp[0][j] = values[0];
	}
	//动态规划，填表
   	//因为第一行是要单独初始化的，后面还要建立在第一行的基础上，所以i初始值为1
	for (int i = 1; i < weights.size(); i++) {
		for (int j = 0; j <= bag_weight; j++) {
            //第一种情况，第i个物品就算单独放也不行；第二种情况，拿上一个没i的结果和有i的比较
			if (j < weights[i]) {
				dp[i][j] = dp[i - 1][j];
			}
			else {
				dp[i][j] = max(dp[i - 1][j], dp[i-1][j-weights[i]] + values[i]);
			}
		}
	}
	//统计拿走的东西种类
	for (int i = weights.size() - 1, j = bag_weight; i > 0; i--) {
		if (dp[i][j] > dp[i - 1][j]) {
			result.push_back(i);
			j -= weights[i];
		}
		if (i == 1 && dp[i][j] !=values[i]) {//如果dp[1][j]的不等于values[1]
			result.push_back(0);
		}
	}
}

int main()
{
	int num,weight, value,bag_weight;
	vector <int> weights ;
	vector<int> values ;
	vector<int>result;
	cout << "Please enter the number of weights and values!" << endl;//输入东西种类数量
	cin >> num;
	//分别输入重量和价值
	cout << "Please enter the  weights! " << endl;
	for (int i = 0; i < num;i++) {
		cin >> weight;
		weights.push_back(weight);
	}
	cout << "Please enter the values!" << endl;
	for (int i = 0; i < num; i++) {
		cin >> value;
		values.push_back(value);
	}
	cout << "Please enter the weight of bag!" << endl;
	cin>> bag_weight ;
	vector<vector<int>> dp(weights.size() + 1, vector<int>(bag_weight + 1, 0));
	Bp(weights,values,dp,bag_weight,result);
	//输出总额和拿走的东西种类
	cout <<"The total prize is :" << dp[weights.size() - 1][bag_weight] << endl;
	cout << "The way of result is :" << endl;
	for (auto it = result.rbegin(); it != result.rend();it++) {
		cout << *it << " ";
	}
	return 0;
}

二、讲解

关于dp数组：

**dp[i][j]表示在考虑前i个物品，并且背包容量为j的情况下，能够获得的最大价值。**这样的一个二维数组可以用来记录不同状态下的最优解，其中i表示物品的编号（从0开始），j表示背包的容量。根据题目的要求，我们希望找到dp[weights.size() - 1][bag_weight]，即在考虑所有物品，且背包容量为bag_weight的情况下，能够获得的最大价值。

第一步：初始化

for (int j = weights[0]; j <= bag_weight; j++) {
    dp[0][j] = values[0];
}

在动态规划中，我们通常需要构建一个状态转移表格（dp数组）来记录状态的变化，在01背包问题中，我们有两个状态：背包容量和物品编号。这里的代码初始化了第一行，表示只有第一个物品时，对于不同背包容量的情况下，能够获得的最大价值。这是一个边界条件，因为只有一个物品，所以它要么放入背包，要么不放入，所以++只有当背包容量大于等于第一个物品的重量时，才能将其放入背包，获得对应的价值++。

第二步：动态规划，填表

for (int i = 1; i < weights.size(); i++) {
    for (int j = 0; j <= bag_weight; j++) {
        if (j < weights[i]) {
            dp[i][j] = dp[i - 1][j];
        } else {
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]);
        }
    }
}

这部分代码构建了整个dp数组。在这里，我们逐步考虑每个物品，以及在不同背包容量下获得的最大价值。对于每个物品，我们有两个选择：放入背包或者不放入背包。每个单元格dp[i][j]的值是根据以下两种情况来确定的：

1. 如果第i个物品的重量weights[i]大于当前背包容量j，那么不能将第i个物品放入背包，所以最大价值与上一个状态dp[i-1][j]相同。
2. 如果第i个物品的重量weights[i]小于等于当前背包容量j，那么我们有两种选择：放入第i个物品或者不放入。我们需要比较这两种选择对应的最大价值，选择其中较大的值作为dp[i][j]的值。

第三步：回溯，找到选择方案

for (int i = weights.size() - 1, j = bag_weight; i > 0; i--) {
    if (dp[i][j] > dp[i - 1][j]) {
        result.push_back(i);
        j -= weights[i];
    }
    if (i == 1 && dp[i][j] != values[i]) {
        result.push_back(0);
    }
}

这部分代码用于回溯，找出实际选择了哪些物品放入背包，从而达到最大价值。从dp数组的右下角（即dp[weights.size() - 1][bag_weight]）开始，我们倒退遍历dp数组。如果发现当前位置的最大价值与上一行相同，说明当前物品没有放入背包，我们直接跳到上一行；如果不同，说明当前物品放入了背包，我们将其记录在result中，并将背包容量减去该物品的重量，然后继续向上遍历。还有一种额外情况，就是如果在遍历到第一个物品时，背包容量还有剩余，且最终的最大价值不等于第一个物品的价值，说明第一个物品也被放入了背包。

总结

这个算法的思路是通过动态规划解决01背包问题。它从初始状态出发，通过填充dp数组来逐步构建出最优解。然后通过回溯，找出实际的选择方案。在动态规划的过程中，关键在于将问题分解为子问题，通过比较不同选择来得出最优解，最终获得整体的最优解。

三、进阶（用一维数组解决问题）

我们创建了一个一维向量 dp，其中 dp[i] 表示在背包容量为 i 时可以达到的最大总价值。这个向量的长度是 bag_Weight + 1，因为背包的容量从0到bag_Weight。

现在让我们来思考动态规划的递推过程。我们要从第一个物品开始，逐步考虑加入更多的物品，直到考虑完所有物品。为了实现这个过程，我们使用了两个嵌套的循环。外层循环遍历所有的物品，内层循环遍历从背包的最大承重开始，逐步减少背包的容量。

在内层循环中，我们要考虑两种情况：放入当前物品和不放入当前物品。我们通过比较这两种情况来决定背包在当前容量下的最优解。具体来说，如果当前物品的重量不超过背包的当前容量（即 j >= weight[i]），我们就可以尝试放入这个物品，然后在背包剩余容量为 j - weight[i] 时找到前一个状态的最优解，加上当前物品的价值。这个过程保证了在考虑前 i 个物品的情况下，背包容量为 j 的最优解。

在比较放入和不放入当前物品的情况后，我们将较大的值赋给 dp[j]，表示背包容量为 j 时的最大总价值。这个过程通过逐渐增加物品数量和背包容量，使得我们可以在最终考虑完所有物品时，得到背包的最优解。

最终，当我们完成外层和内层循环后，dp[bag_Weight] 就存储了问题的最终解，即背包的最大总价值。我们输出这个值，就完成了整个过程。

为什么for循环外层遍历物品，而内层遍历重量？

1. 外层循环遍历物品（i 的变化）： 当我们考虑第 i 个物品时，我们已经考虑了前 i-1 个物品的情况，假设这些子问题的解已经计算出来并存储在 dp 数组中。外层循环在不同的 i 值下，使得我们能够逐个考虑每个物品，并在 dp 数组中记录之前子问题的解。
2. 内层循环遍历背包容量（j 的变化）： 对于每个物品 i，我们需要考虑在背包容量从 bagWeight 逐渐减少到 0 的过程中，如何得到最大总价值。这是因为我们希望逐步填充 dp 数组中更大的背包容量，依赖于之前较小容量下的最优解。通过从 bagWeight 减少到 0 的循环顺序，我们可以确保在计算当前背包容量 j 下的最优解时，之前的更小容量下的解已经计算出来。

#include<iostream>
using namespace std;
#include <vector>
void Bp() {
    vector<int> weight = { 1, 3, 4 };
    vector<int> value = { 15, 20, 30 };
    int bag_Weight = 4;

    vector<int> dp(bag_Weight + 1, 0);
    for (int i = 0; i < value.size(); i++) {
        for (int j = bag_Weight; j >= weight[i]; j--) {
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bag_Weight] << endl;
}


int main() {
    Bp();
}