【算法】背包问题

一、01背包

01背包就是只有拿或者不拿两种状态

1、二维数组版

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

void test() {
	vector<int> weight = {1, 3, 4};       // 物品的容量
	vector<int> value = {15, 20, 30};     // 物品的价值
	int bagweight = 4;                    // 背包最大空间
	
	// 二维数组
	// dp[i][j]表示从下标为0-i的物品里面任意取，放进容量为j的背包，总价值和最大是多少
	vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
	
	
	// 初始化
	// 当前空间大于第0个物品时，可以将第0个物品放到背包
	for (int j = weight[0]; j <= bagweight; j++) {
		dp[0][j] = value[0];
	}
	
	// 遍历
    // 这里递推公式比较好理解，遍历顺序先遍历物品和先遍历背包都可以
	for (int i = 1; i < weight.size(); i++) {
		for (int j = 0; j <= bagweight; j++) {
            // 当前空间小于背包容量时，保持原状态不变
			if (j < weight[i]) {
				dp[i][j] = dp[i - 1][j];
			} else {
                // 此时的最大价值是max(不放物品的价值, 放物品的价值)
				dp[i][j] = max(dp[i - 1][j], dp[i - i][j - weight[i]] + value[i]);
			}
		}
	}
	cout << dp[weight.size() - 1][bagweight] << endl;
}


int main()
{
	test();
	return 0;
}

2、一维数组版

难理解

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

void test() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    // 初始化
	// 先遍历物品，后遍历背包容量
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test();
	return 0;
}

二、完全背包

完全背包就是物品是无限的

1、一维数组版

先遍历物品

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

void test() {
    vector<int> weight = {1, 3, 4};      // 物品体积
    vector<int> value = {15, 20, 30};    // 物品价值
    int bagSize = 4;                     // 背包容量
    vector<int> dp(bagSize + 1, 0);
    // 先遍历物品和先遍历背包都行
    // 先遍历物品
    for (int i = 0; i < weight.size(); i++) {
        for (int j = weight[i]; j <= bagSize; j++) {
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagSize]<<endl;
}


int main()
{
    test();
    return 0;
}

先遍历背包

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

void test() {
    vector<int> weight = {1, 3, 4};      // 物品体积
    vector<int> value = {15, 20, 30};    // 物品价值
    int bagSize = 4;                     // 背包容量
    vector<int> dp(bagSize + 1, 0);
    // 先遍历物品和先遍历背包都行
    // 先遍历背包
    for (int j = 0; j <= bagSize; j++) {
        for (int i = 0; i < weight.size(); i++) {
            if (j >= weight[i]) {
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
    }
    
    
    cout << dp[bagSize]<<endl;
}


int main()
{
    test();
    return 0;
}

三、多重背包

有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi

。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。

多重背包和01背包是非常像的， 为什么和01背包像呢？

每件物品最多有Mi件可用，把Mi件摊开，其实就是一个01背包问题了。

例如：

背包最大重量为10。

物品为：

	重量	价值	数量
物品0	1	15	2
物品1	3	20	3
物品2	4	30	2

问背包能背的物品最大价值是多少？

和如下情况有区别么？

	重量	价值	数量
物品0	1	15	1
物品0	1	15	1
物品1	3	20	1
物品1	3	20	1
物品1	3	20	1
物品2	4	30	1
物品2	4	30	1

毫无区别，这就转成了一个01背包问题了，且每个物品只用一次。

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

void test() {
	vector<int> weight = {1, 3, 4};     // 物品重量
	vector<int> value = {15, 20, 30};   // 物品价值
	vector<int> nums = {2, 3, 2};       // 物品数量
	
	int bagweight = 10;                 // 背包重量
	
	// 把nums[i]保留到1，把物品都展开，转成01背包
	for (int i = 0; i < nums.size(); i++) {
		while (nums[i] > 1) {
			weight.push_back(weight[i]);
			value.push_back(value[i]);
			nums[i]--;
		}
	}
	
	vector<int> dp(bagweight + 1, 0);
	// 先遍历背包
	for (int i = 0; i < weight.size(); i++) {
		// 再遍历背包容量
		for (int j = bagweight; j >= weight[i]; j--) {
			dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
		}
		// 输出每一轮
		for (int j = 0; j <= bagweight; j++) {
			cout << dp[j] << endl;
		}
		cout << endl;
	}
	cout << "最大价值：" <<dp[bagweight] << endl;
}

int main(int argc, char** argv)
{
   test();
   return 0;
}

四、总结

一维版

//01背包
for (int i = 0; i < n; i++) {
    for (int j = m; j >= V[i]; j--) {
        f[j] = max(f[j], f[j-V[i]] + W[i]);
    }
}


//完全背包
for (int i = 0; i < n; i++) {
    for (int j = V[i]; j <= m; j++) {
        f[j] = max(f[j], f[j-V[i]] + W[i]);
    }
}

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。