1 动态规划概述
动态规划（Dynamic Programming，简称DP）是一种解决多阶段决策问题的数学优化方法。它将原问题分解成若干个子问题，通过解决子问题只需解决一次并将结果保存下来，从而避免了重复计算，提高了算法效率。 通俗来讲，动态规划算法是解决一类具有重叠子问题和最优子结构性质的问题的有效方法。其基本原理是将大问题分解为小问题，通过保存中间结果来避免重复计算，从而提高算法的效率。 动态规划主要包括两个要素：最优子结构和重叠子问题。
2 线性DP
线性动态规划，在本节中是一个非常广义的概念，不局限于“线性时间复杂度”的一维动态规划。与数学中的“线性空间”类似，如果一个动态规划算法的“状态”包含多个维度，但在每个维度上都具有“线性”变化的“阶段”，那么该动态规划算法同样称为“线性DP”
2.1 最长公共子序列（LCS）
最长公共子序列是指给定两个序列，找出它们之间最长的公共子序列的长度。这个问题经常用于比较两个序列的相似性
模板
vector<vector<int>> LCSLength(string s1, string s2){
/* 计算最长公共子序列的长度 */
int n = s1.size(), m = s2.size();
vector<vector<int>> dp(n+1, vector<int>(m+1));
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (s1[i] == s2[j])dp[i][j] = dp[i - 1][j - 1] + 1;
else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
return dp;
}例题
#include<iostream>
#include<vector>
using namespace std;
int main() {
int n, m; cin >> n >> m;
vector<int> v1(n+1);
vector<int> v2(m+1);
for (int i = 1; i <= n; i++)cin >> v1[i];
for (int i = 1; i <= m; i++)cin >> v2[i];
vector<vector<int>> dp(n+1,vector<int>(m+1));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (v1[i] == v2[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
cout << dp[n][m] << endl;
return 0;
}2.1 最长上升子序列（LIS）
最长递增子序列是指在一个序列中找到一个最长的子序列，使得子序列中的元素是递增的。这个问题经常用于寻找序列中的递增部分
模板
vector<int> LISLength(vector<int> v) {
int n = v.size();
vector<int> dp(n,1);
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++)
if (v[j] > v[i])dp[i] = max(dp[i], dp[j] + 1);
return dp;
}例题
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
int n; cin >> n;
vector<int> arr(n), dp(n,1);
for (int& i : arr)cin >> i;
for (int i = 0; i < n; i++)
for (int j = 0; j <i; j++)
if (arr[i] > arr[j])dp[i] = max(dp[i], dp[j] + 1);
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}3 背包问题
3.1 01背包
指在限定总重量的情况下，选择不同物品装入背包，使得装入背包的物品总价值最大。每种物品只能选择一次
模板
for (int i = 1; i <= n; i++) //当前装第 i 件物品
for (int j = W; j >= w[i]; j--) //背包容量为 j
dp[j] = max(dp[j], dp[j - w[i]] + v[i]); //判断背包容量为 j 的情况下能是实现总价值例题
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct thing { int w, v; };
int main() {
int N, V; cin >> N >> V;
vector<thing> arr(N);
vector<int> dp(V+1);
for (thing& t : arr)cin >> t.w >> t.v;
for (thing& t : arr)for (int i = V; i >= t.w; i--)
dp[i] = max(dp[i], dp[i - t.w] + t.v);
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}3.2 完全背包
类似于01背包，但是每种物品可以选择无限次放入背包，即每种物品的数量是无限的
模板
for (int i = 1; i <= n; i++)
for (int j = w[i]; j <= W; j++)
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);例题
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct thing { int w, v; };
int main() {
int N, V; cin >> N >> V;
vector<thing> arr(N);
vector<int> dp(V+1);
for (thing& t : arr)cin >> t.w >> t.v;
for (thing& t : arr)for (int i = t.w; i <= V; i++)
dp[i] = max(dp[i], dp[i - t.w] + t.v);
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}3.3 多重背包
在限定总重量的情况下，选择不同物品装入背包，但每种物品有限制的数量。每种物品可以选择多次，但是有数量限制
模板
for (int i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &x, &y, &s); //x 为体积， y 为价值， s 为数量
for(int t=1;t<s;t<<=1){
w[++num] = x * t;
v[num] = y * t;
s -= t;
}
w[++num] = x * s;
v[num] = y * s;
}
for (int i = 1; i <= num; i++)
for (int j = W; j >= w[i]; j--)
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);例题
无优化
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct thing { int w, v, s; };
int main() {
int N, V; cin >> N >> V;
vector<thing> arr(N);
vector<int> dp(V + 1);
for (thing& t : arr)cin >> t.w >> t.v >> t.s;
for (thing& t : arr)
for(int j=0;j<t.s;j++)//循环s次
for (int i = V; i >= t.w; i--)
dp[i] = max(dp[i], dp[i - t.w] + t.v);
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}二进制优化
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct thing {
int w, v, s;
thing() : w(0), v(0), s(0) {} // 默认构造函数
thing(int a, int b, int c) : w(a), v(b), s(c) {} // 接受三个整数参数的构造函数
};
int main() {
int N, V; cin >> N >> V;
vector<thing> trr(N);
vector<int> dp(V + 1);
vector<thing> arr;
for (thing& t : trr)cin >> t.w >> t.v >> t.s;
for (thing t : trr) {
for (int i = 1; t.s; i <<= 1) {
if (i <= t.s) {
arr.push_back(thing(i*t.w,i*t.v,1));
t.s -= i;
}
else {
arr.push_back(thing(t.s * t.w, t.s * t.v, 1));
t.s = 0;
}
}
}
for (thing t : arr)
for (int i = V; i >= t.w; i--)
dp[i] = max(dp[i], dp[i - t.w] + t.v);
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}3.4 二维费用背包
在背包问题中，每种物品除了重量外还有另一个维度的费用（比如体积、价值等），需要考虑两种费用维度的情况
模板
for (int i = 1; i <= n; i++)
for (int j = W; j >= w; j--) //容量限制
for (int k = M; k >= m; k--) //重量限制
dp[j][k] = max(dp[j][k], dp[j - w][k - m] + v);例题
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct thing { int w, v, m; };
int main() {
int N, V, M; cin >> N >> V >> M;
vector<thing> arr(N);
vector<vector<int>> dp(V + 1, vector<int>(M+1));
for (thing& t : arr)cin >> t.v >> t.m >> t.w;;
for (thing t : arr)
for (int i = V; i >= t.v; i--)
for (int j = M; j >= t.m; j--)
dp[i][j] = max(dp[i][j], dp[i - t.v][j - t.m] + t.w);
int ans = 0;
for (auto v : dp)for (int i : v)ans = max(ans, i);
cout << ans << endl;
return 0;
}3.5 分组背包
将物品按照一定的分组方式进行划分，每组内的物品只能选择一个放入背包，需要考虑分组的情况
模板
int n, W, s[N], w[N][N], v[N][N], dp[N];
for (int i = 1; i <= n; i++)
for (int j = W; j >= 0; j--)
for (int k = 1; k <= s[i]; k++)
if (j - w[i][k] >= 0)dp[j] = max(dp[j], dp[j - w[i][k]] + v[i][k]);例题
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct thing { int w, v; };
int main() {
int N, V; cin >> N >> V;
vector<vector<thing>> arr(N);
vector<int> dp(V + 1);
for (auto& v : arr) {
int s; cin >> s;
v=vector<thing>(s);
for (thing& t : v)cin >> t.w >> t.v;
}
for (auto v : arr)
for (int i = V; i >= 0; i--)
for (thing t : v)
if (i >= t.w)dp[i] = max(dp[i], dp[i - t.w] + t.v);
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
}
1001
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
