DP-背包问题

仅供自己记录

01背包问题

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

#include<bits/stdc++.h>
#include<cstdio>
#pragma warning(disable:4996)//cscanf
using namespace std;
typedef long long ll;


int main() {
	int N, V, vi, wi;
	cin >> N >> V;
	vector<int>capacity(N+1, 0);
	vector<int>value(N+1, 0);
	
	int** dp = new int* [N];
	for (int i = 0; i < N+1; i++) {
		dp[i] = new int[V];
	}
	for (int i = 0; i < N+1; i++) {
		for (int j = 0; j < V; j++) {
			dp[i][j] = 0;
		}
	}




	for (int i = 1; i < N+1; i++) {
		cin >> vi >> wi;
		capacity[i] = vi;
		value[i] = wi;
	}

	for (int i = 1; i <=N; i++) {
		for (int j = 1; j <=V; j++) {
			if (j >= capacity[i])
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - capacity[i]] + value[i]);
			else dp[i][j] = dp[i - 1][j];
		}
	}

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

#include<bits/stdc++.h>
#include<cstdio>
#pragma warning(disable:4996)//cscanf
using namespace std;
typedef long long ll;

int N, V;
int dp[1000];

int main() {
	int vi, wi;
	cin >> N >> V;
	vector<int>capacity(N+1, 0);
	vector<int>value(N+1, 0);
	
	for (int i = 1; i < N+1; i++) {
		cin >> vi >> wi;
		capacity[i] = vi;
		value[i] = wi;
	}

	for (int i = 1; i <=N; i++) {
		for (int j =V; j >=capacity[i]; j--) {
			dp[j]= max(dp[j], dp[j - capacity[i]] + value[i]);
		}
	}

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

完全背包问题

题目
提交记录
讨论
题解
视频讲解

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10

#include<bits/stdc++.h>
#include<cstdio>//csanf
#pragma warning(disable:4996)//cscanf
using namespace std;
typedef long long ll;

int N, V;
int dp[1000];

int main() {
	int vi, wi;
	cin >> N >> V;
	vector<int>capacity(N+1, 0);
	vector<int>value(N+1, 0);
	
	for (int i = 1; i < N+1; i++) {
		cin >> vi >> wi;
		capacity[i] = vi;
		value[i] = wi;
	}

	for (int i = 1; i <=N; i++) {
		for (int j = capacity[i]; j<=V; j++) {
			dp[j]= max(dp[j], dp[j - capacity[i]] + value[i]);
		}
	}

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

多重背包问题 I

题目
提交记录
讨论
题解
视频讲解

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤100
0<vi,wi,si≤100
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

#include<bits/stdc++.h>
#include<cstdio>//csanf
#pragma warning(disable:4996)//cscanf
using namespace std;
typedef long long ll;

int N, V;
int dp[1000];

int main() {
	int vi, wi,si;
	cin >> N >> V;
	vector<int>capacity(N+1, 0);
	vector<int>value(N+1, 0);
	vector<int>number(N + 1, 0);

	for (int i = 1; i < N+1; i++) {
		cin >> vi >> wi >> si;
		capacity[i] = vi;
		value[i] = wi;
		number[i] = si;
	}

	for (int i = 1; i <=N; i++) {
		for (int j =V; j>= capacity[i]; j--) {
			for (int k = 1; k <= number[i]&&(k*capacity[i]<=j); k++) {
					dp[j]= max(dp[j], dp[j - capacity[i]*k] + value[i]*k);
			}
		}
	}

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

3n 块披萨

给你一个披萨，它由 3n 块不同大小的部分组成，现在你和你的朋友们需要按照如下规则来分披萨：

你挑选 任意 一块披萨。
Alice 将会挑选你所选择的披萨逆时针方向的下一块披萨。
Bob 将会挑选你所选择的披萨顺时针方向的下一块披萨。
重复上述过程直到没有披萨剩下。
每一块披萨的大小按顺时针方向由循环数组 slices 表示。

请你返回你可以获得的披萨大小总和的最大值。

示例 1：

输入：slices = [1,2,3,4,5,6]
输出：10
解释：选择大小为 4 的披萨，Alice 和 Bob 分别挑选大小为 3 和 5 的披萨。然后你选择大小为 6 的披萨，Alice 和 Bob 分别挑选大小为 2 和 1 的披萨。你获得的披萨总大小为 4 + 6 = 10 。
示例 2：

输入：slices = [8,9,8,6,1,1]
输出：16
解释：两轮都选大小为 8 的披萨。如果你选择大小为 9 的披萨，你的朋友们就会选择大小为 8 的披萨，这种情况下你的总和不是最大的。
示例 3：

输入：slices = [4,1,2,5,8,3,1,9,7]
输出：21
示例 4：

输入：slices = [3,1,2]
输出：3

提示：

1 <= slices.length <= 500
slices.length % 3 == 0
1 <= slices[i] <= 1000

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/dynamic-programming-1-plus/5rlibc/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
public:
	int selectMax(vector<int>& slices) {
		int len = slices.size();
		int dp[1001][501];
		memset(dp, 0, sizeof(dp));
		for (int i = 1; i <= len; i++) {
			for (int j = 1; j <= (len + 1) / 3; j++) {
				dp[i][j] = max(dp[i - 1][j], (i - 2 >= 0 ? dp[i - 2][j - 1] : 0) + slices[i - 1]);
			}
		}
		return dp[len][(len + 1) / 3];
	}
	int maxSizeSlices(vector<int>& slices) {
		vector<int>v1(slices.begin() + 1, slices.end());
		vector<int>v2(slices.begin(), slices.end() - 1);
		return max(selectMax(v1), selectMax(v2));
	}
};