分组背包、完全背包
分组背包、完全背包
分组背包：多个物品分组，每组只能取1件。每一组的物品都可能性展开就可以了。时间复杂度 O(物品数量 * 背包容量)
完全背包：与 01 背包的区别仅在于每种商品可以选取无限次。时间复杂度 O(物品数量 * 背包容量)
P1757 通天之分组背包
- 严格位置依赖的动态规划
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 时间复杂度 O(m * n)
int main() {
// n 件物品，背包容量 m
int m, n;
cin >> m >> n;
vector<vector<int>> arr(n + 1, vector<int>(3));
for (int i = 1; i <= n; ++i)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
// 根据组号排序
sort(begin(arr), end(arr),
[](vector<int> &v1, vector<int> &v2) {
return v1[2] < v2[2];
});
// 组数
int teams = 1;
for (int i = 2; i <= n; ++i)
if (arr[i][2] != arr[i - 1][2]) teams++;
// dp[i][j] 表示从前面 i 个组中选取（每个组最多选一个），总重量不超过 j 时能获得的最大收益
vector<vector<int>> dp(teams + 1, vector<int>(m + 1));
// 首行为 0
fill(begin(dp[0]), end(dp[0]), 0);
for (int l = 1, r = 2, i = 1; l <= n; ++i) {
// r 移动到下一组的开头
while (r <= n && arr[l][2] == arr[r][2]) r++;
// [l, r-1] 为当前组的物品
for (int j = 0; j <= m; ++j) {
// 一个都不选
dp[i][j] = dp[i - 1][j];
// 尝试选则组内的每一个
for (int k = l; k < r; ++k)
if (j - arr[k][0] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - arr[k][0]] + arr[k][1]);
}
// 处理下一组
l = r++;
}
cout << dp[teams][m];
}
- 空间优化
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 时间复杂度 O(m * n)
int main() {
// n 件物品，背包容量 m
int m, n;
cin >> m >> n;
vector<vector<int>> arr(n + 1, vector<int>(3));
for (int i = 1; i <= n; ++i)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
// 根据组号排序
sort(begin(arr), end(arr),
[](vector<int> &v1, vector<int> &v2) {
return v1[2] < v2[2];
});
// 组数
int teams = 1;
for (int i = 2; i <= n; ++i)
if (arr[i][2] != arr[i - 1][2]) teams++;
// dp[i][j] 表示从前面 i 个组中选取（每个组最多选一个），总重量不超过 j 时能获得的最大收益
// 首行为 0
vector<int> dp(m + 1, 0);
for (int l = 1, r = 2, i = 1; l <= n; ++i) {
// r 移动到下一组的开头，[l, r-1] 为当前组的物品
while (r <= n && arr[l][2] == arr[r][2]) r++;
// 从右往左
for (int j = m; j >= 0; --j) {
// 一个都不选，或者尝试选则组内的每一个
for (int k = l; k < r; ++k)
if (j - arr[k][0] >= 0)
dp[j] = max(dp[j], dp[j - arr[k][0]] + arr[k][1]);
}
// 处理下一组
l = r++;
}
cout << dp[m];
}
2218. 从栈中取出 K 个硬币的最大面值和
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
int maxValueOfCoins(vector<vector<int>> &piles, int m) {
// 组数
int n = piles.size();
// dp[i][j] 表示前 i 组上，一共拿走 j 个硬币的情况下，获得的最大价值
vector<vector<int>> dp(n + 1, vector<int>(m + 1));
// 组号从 1 开始
for (int i = 1; i <= n; ++i) {
// 当前组
vector<int> team = piles[i - 1];
// 计算前缀和
int t = min((int) team.size(), m);
vector<int> preSum(t + 1);
for (int j = 1; j <= t; ++j)
preSum[j] = preSum[j - 1] + team[j - 1];
// 更新动态规划表
for (int j = 0; j <= m; ++j) {
// 当前组一个硬币也不拿
dp[i][j] = dp[i - 1][j];
// i 组里拿走前 k 个硬币的方案
for (int k = 1; k <= min(t, j); ++k)
dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + preSum[k]);
}
}
return dp[n][m];
}
};
- 空间优化
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
int maxValueOfCoins(vector<vector<int>> &piles, int m) {
// 组数
int n = piles.size();
// dp[i][j] 表示前 i 组上，一共拿走 j 个硬币的情况下，获得的最大价值
// 首行全 0
vector<int> dp(m + 1, 0);
// 组号从 1 开始
for (int i = 1; i <= n; ++i) {
// 当前组
vector<int> team = piles[i - 1];
// 计算前缀和
int t = min((int) team.size(), m);
vector<int> preSum(t + 1);
for (int j = 1; j <= t; ++j)
preSum[j] = preSum[j - 1] + team[j - 1];
// 更新动态规划表
for (int j = m; j >= 0; j--) {
// 当前组一个硬币也不拿
// i 组里拿走前 k 个硬币的方案
for (int k = 1; k <= min(t, j); ++k)
dp[j] = max(dp[j], dp[j - k] + preSum[k]);
}
}
return dp[m];
}
};
P1616 疯狂的采药
完全背包(模版)
给定一个正数 t，表示背包的容量
有 m 种货物，每种货物可以选择任意个
每种货物都有体积 costs[i] 和价值 values[i]
返回在不超过总容量的情况下，怎么挑选货物能达到价值最大
返回最大的价值
- 严格位置依赖的动态规划
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define ll long long
int main() {
int t, m;
cin >> t >> m;
vector<int> cost(m + 1);
vector<int> value(m + 1);
for (int i = 1; i <= m; ++i)
cin >> cost[i] >> value[i];
// dp[i][j] 表示前 i 号物品，每种可以无限拿，总代价不超过 j 的情况下，能获得的最大价值
vector<vector<ll>> dp(m + 1, vector<ll>(t + 1));
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= t; ++j) {
// 当前物品一个都不拿
dp[i][j] = dp[i - 1][j];
// 当前物品拿若干个
if (j - cost[i] >= 0)
dp[i][j] = max(dp[i][j], dp[i][j - cost[i]] + value[i]);
}
}
cout << dp[m][t];
}
- 空间压缩
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define ll long long
int main() {
int t, m;
cin >> t >> m;
vector<int> cost(m + 1);
vector<int> value(m + 1);
for (int i = 1; i <= m; ++i)
cin >> cost[i] >> value[i];
// dp[i][j] 表示前 i 号物品，每种可以无限拿，总代价不超过 j 的情况下，能获得的最大价值
// 首行全 0
vector<ll> dp(t + 1, 0);
for (int i = 1; i <= m; ++i) {
// 从左往右
for (int j = cost[i]; j <= t; ++j) {
// 当前物品一个都不拿
// 当前物品拿若干个
dp[j] = max(dp[j], dp[j - cost[i]] + value[i]);
}
}
cout << dp[t] << endl;
}
10. 正则表达式匹配
- 暴力递归
#include <iostream>
using namespace std;
class Solution {
public:
// s 从 i 下标开始能不能被 p 从 j 下标开始完全匹配出来
bool recursive(string s, string p, int i, int j) {
// 1. s 没后缀
if (i == s.length()) {
// 同时 p 也没后缀
if (j == p.length()) return true;
// p 还剩下一些后缀
// 如果 p[j+1] 是 *，那么 p[j, j+1]可以消掉，然后看看再剩下的是不是都能消掉
return j + 1 < p.length() && p[j + 1] == '*' && recursive(s, p, i, j + 2);
}
// 2. s 有后缀，p 没后缀
if (j == p.length()) return false;
// 3. 都有后缀
// 3.1 j+1 位置不是 *
if (j + 1 == p.length() || p[j + 1] != '*')
return (s[i] == p[j] || p[j] == '.') && recursive(s, p, i + 1, j + 1);
// 3.2 j+1 位置是 *
// 完全背包
// 选择1: 当前 p[j, j+1] 变成空，用 p 的 j+2 位置开始和 s 的 i 位置匹配
bool p1 = recursive(s, p, i, j + 2);
// 选择2: (s[i] == p[j] || p[j] == '.') 时，当前 p[j..j+1] 消去 s[i]
bool p2 = (s[i] == p[j] || p[j] == '.') && recursive(s, p, i + 1, j);
return p1 || p2;
}
bool isMatch(string s, string p) {
return recursive(s, p, 0, 0);
}
};
- 记忆化搜索
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
// s 从 i 下标开始能不能被 p 从 j 下标开始完全匹配出来
bool recursive(string s, string p, int i, int j, vector<vector<int>> &dp) {
if (dp[i][j] != 0) return dp[i][j] == 1;
bool res;
if (i == s.length()) {
// 1. s 没后缀
// 同时 p 也没后缀
if (j == p.length()) {
res = true;
} else {
// p 还剩下一些后缀
// 如果 p[j+1] 是 *，那么 p[j, j+1]可以消掉，然后看看再剩下的是不是都能消掉
res = j + 1 < p.length() && p[j + 1] == '*' && recursive(s, p, i, j + 2, dp);
}
} else if (j == p.length()) {
// 2. s 有后缀，p 没后缀
res = false;
} else {
if (j + 1 == p.length() || p[j + 1] != '*') {
// 3. 都有后缀
// 3.1 j+1 位置不是 *
return (s[i] == p[j] || p[j] == '.') && recursive(s, p, i + 1, j + 1, dp);
} else {
// 3.2 j+1 位置是 *
// 完全背包
// 选择1: 当前 p[j, j+1] 变成空，用 p 的 j+2 位置开始和 s 的 i 位置匹配
bool p1 = recursive(s, p, i, j + 2, dp);
// 选择2: (s[i] == p[j] || p[j] == '.') 时，当前 p[j..j+1] 消去 s[i]
bool p2 = (s[i] == p[j] || p[j] == '.') && recursive(s, p, i + 1, j, dp);
res = p1 || p2;
}
}
dp[i][j] = res ? 1 : 2;
return res;
}
bool isMatch(string s, string p) {
// 记忆化搜索
// dp[i][j] == 0，表示没算过
// dp[i][j] == 1，表示算过，答案是 true
// dp[i][j] == 2，表示算过，答案是 false
vector<vector<int>> dp(s.size() + 1, vector<int>(p.size() + 1, 0));
return recursive(s, p, 0, 0, dp);
}
};
- 严格位置依赖的动态规划
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
// 根据递归改写
bool isMatch(string s, string p) {
int n = s.length();
int m = p.length();
vector<vector<bool>> dp(s.size() + 1, vector<bool>(p.size() + 1));
dp[n][m] = true;
for (int j = m - 1; j >= 0; j--)
dp[n][j] = j + 1 < m && p[j + 1] == '*' && dp[n][j + 2];
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (j + 1 == m || p[j + 1] != '*') {
dp[i][j] = (s[i] == p[j] || p[j] == '.') && dp[i + 1][j + 1];
} else {
dp[i][j] = dp[i][j + 2] || ((s[i] == p[j] || p[j] == '.') && dp[i + 1][j]);
}
}
}
return dp[0][0];
}
};
44. 通配符匹配
- 暴力递归
#include <iostream>
#include <vector>
using namespace std;
// '?' 表示可以变成任意字符，数量 1 个
// '*' 表示可以匹配任何字符串
class Solution {
public:
bool recursive(string s, string p, int i, int j) {
// 1. s 没后缀
if (i == s.length()) {
// 同时 p 也没后缀
if (j == p.length()) return true;
// p 还剩下一些后缀
// 如果 p[j] 是 *，那么 p[j]可以消掉，然后看看再剩下的是不是都能消掉
return p[j] == '*' && recursive(s, p, i, j + 1);
}
// 2. s 有后缀，p 没后缀
if (j == p.length()) return false;
// 3. 都有后缀
// 3.1 j 位置不是 *，那么当前的字符必须能匹配
if (p[j] != '*') return (s[i] == p[j] || p[j] == '?') && recursive(s, p, i + 1, j + 1);
// 3.2 j 位置是 *，可以选择消掉或者不消掉 s[i]
return recursive(s, p, i + 1, j) || recursive(s, p, i, j + 1);
}
bool isMatch(string s, string p) {
return recursive(s, p, 0, 0);
}
};
- 记忆化搜索
#include <iostream>
#include <vector>
using namespace std;
// '?' 表示可以变成任意字符，数量 1 个
// '*' 表示可以匹配任何字符串
class Solution {
public:
bool recursive(string s, string p, int i, int j, vector<vector<int>> &dp) {
if (dp[i][j] != 0) return dp[i][j] == 1;
bool res;
if (i == s.length()) {
if (j == p.length()) {
res = true;
} else {
res = p[j] == '*' && recursive(s, p, i, j + 1, dp);
}
} else if (j == p.length()) {
res = false;
} else {
if (p[j] != '*') {
res = (s[i] == p[j] || p[j] == '?') && recursive(s, p, i + 1, j + 1, dp);
} else {
res = recursive(s, p, i + 1, j, dp) || recursive(s, p, i, j + 1, dp);
}
}
dp[i][j] = res ? 1 : 2;
return res;
}
bool isMatch(string s, string p) {
vector<vector<int>> dp(s.length() + 1, vector<int>(p.length() + 1));
return recursive(s, p, 0, 0, dp);
}
};
- 严格位置依赖
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
bool isMatch(string s, string p) {
int n = s.length();
int m = p.length();
vector<vector<bool>> dp(n + 1, vector<bool>(m + 1));
dp[n][m] = true;
for (int j = m - 1; j >= 0 && p[j] == '*'; j--)
dp[n][j] = true;
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (p[j] != '*') {
dp[i][j] = (s[i] == p[j] || p[j] == '?') && dp[i + 1][j + 1];
} else {
dp[i][j] = dp[i + 1][j] || dp[i][j + 1];
}
}
}
return dp[0][0];
}
};
P2918 [USACO08NOV] Buying Hay S
#include <iostream>
#include <vector>
using namespace std;
// 购买足量干草的最小花费
// 有 n 个提供干草的公司，每个公司都有两个信息
// cost[i] 代表购买 1 次产品需要花的钱
// val[i] 代表购买 1 次产品所获得的干草数量
// 每个公司的产品都可以购买任意次
// 你一定要至少购买 h 数量的干草，返回最少要花多少钱
int main() {
int n, h;
cin >> n >> h;
vector<int> cost(n + 1);
vector<int> value(n + 1);
int _max = 0;
for (int i = 1; i <= n; ++i) {
cin >> value[i] >> cost[i];
_max = max(_max, value[i]);
}
// 往外扩充
int m = h + _max;
// dp[i][j] 表示前 i 个公司里挑公司，购买严格 j 磅干草，需要的最少花费
vector<vector<int>> dp(n + 1, vector<int>(m + 1));
// 首行为最大值表示没有解
fill(dp[0].begin() + 1, dp[0].end(), 0x7fffffff);
// 除了 dp[0][0] 是 0
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
dp[i][j] = dp[i - 1][j];
if (j - value[i] >= 0 && dp[i][j - value[i]] != 0x7fffffff)
dp[i][j] = min(dp[i][j], dp[i][j - value[i]] + cost[i]);
}
}
int res = 0x7fffffff;
// 至少购买 h 数量的干草，返回最少要花多少钱
for (int j = h; j <= m; ++j)
res = min(res, dp[n][j]);
cout << res << endl;
}
- 空间优化
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, h;
cin >> n >> h;
vector<int> cost(n + 1);
vector<int> value(n + 1);
int _max = 0;
for (int i = 1; i <= n; ++i) {
cin >> value[i] >> cost[i];
_max = max(_max, value[i]);
}
// 往外扩充
int m = h + _max;
// dp[i][j] 表示前 i 个公司里挑公司，购买严格 j 磅干草，需要的最少花费
vector<int> dp(m + 1, 0x7fffffff);
// 首行除了 dp[0][0] 是 0，其他都为最大值表示没有解
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = value[i]; j <= m; ++j) {
if (dp[j - value[i]] != 0x7fffffff)
dp[j] = min(dp[j], dp[j - value[i]] + cost[i]);
}
}
int res = 0x7fffffff;
// 至少购买 h 数量的干草，返回最少要花多少钱
for (int j = h; j <= m; ++j)
res = min(res, dp[j]);
cout << res << endl;
}
