什么是动态规划?
动态规划:Dynamic Programmin,因此常用DP指代。定义:
- 将一个大问题拆分为一个个子问题;
- 每个子问题有最优解状态,最终全局最优解状态为子问题最优解状态的递推集合;
- 记录历史,避免重复计算。
动态规划算法步骤
- 定义状态。借助DP数组保存历史记录;DP含义明确,例如:DP[i]表示第i阶梯方案。
- 列出状态转移方程。找出数组之间的关系,这一步有可能是最难的一步。
- 初始化状态。DP[i]个状态的转移方程,跟DP[i - 1]和DP[i - 2]存在关联。
动态规划算法分类
线性算法
算法描述
在线性空间上递推,也就是在一条线上进行。
算法举例--求解最长公共子序列定义
例如:求最长公共子序列力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
算法举例--求解最长公共子序列复杂度
算法举例--求解最长公共子序列代码--c++
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
int n = text1.size(), m = text2.size();
vector<vector<int>> f(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (text1[i - 1] == text2[j - 1]) {
f[i][j] = f[i - 1][j - 1] + 1;
} else {
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
}
}
}
return f[n][m];
}
};
算法举例--求解最长公共子序列分析
状态定义。即f[i][j] = text1的[1, i]和text2的[1, j]区间的最长公共子序列长度;
列出状态转移方程。如果text1[i] == text2[j],则问题进一步拆分为求解text1的[1, i - 1]和text2的[1, j - 1]的最长公共子序列 + 1,即f[i][j] = f[i - 1][j - 1] + 1;如果text1[i] != text2[j],则求解text1的[1,i]和text2的[1,j]最长公共子序列长度无法延长,因此f[i][j]就会继承f[i - 1][j]与f[i][j - 1]中的较大值,即f[i][j] = max(f[i - 1][j],f[i][j - 1]) ;
初始化状态。f[i][0] = f[0][j] = 0。
背包算法
01背包算法定义
N件物品(每种仅1件,选择放或者不放),背包容量V;第i件物品体积v[i],价值w[i];求解怎么放可以获得最大价值。
01背包算法代码--c++
#include<iostream>
using namespace std;
std::vector<int> 01_bag_dp(){
const int N = 1010;
std::vector<int> v = std::vector<int>(N, 0);
std::vector<int> w = std::vector<int>(N, 0);
std::vector<std::vector<int>> dp = std::vector<int>(N + 1, std::vector<int>(N + 1, 0));
int n, m;
cin >> n >> m;
for(int i = 1; i <= n; i++){
cin >> v[i] >> w[i];
}
for(int i = 1; i <= n; i++){
for(int j = 0; j <= m; j++){
if(j < v[i])
dp[i][j] = dp[i - 1][j];
else
dp[i][j]= max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
}
for(int j = m; j >= v[i]; j--){
dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
}
}
return dp[m];
}
01背包算法分析
状态定义。dp[i][V] = 前i件物品恰放入背包后可以获得的最大价值;
列出状态转移方程。dp[i][V] = max(dp[i - 1][V], dp[i - 1][V - v[i] + w[i]]);
初始化状态。f[i][0] = f[0][V] = 0。
01背包算法优化
dp[i][V]实际是dp[i - 1][V]和f[i - 1][V - v[i]]子问题递推而来,因此每i次主循环中,以V递减推dp[v]。因此最后一个for循环加了空间优化。
目标和算法定义
另举一例,为01背包算法变种。给定非负整数数组nums和目标整数
target,
向数组中的每个整数前添加 '+'
或 '-'
,然后串联起所有整数,可以构造一个表达式,表达式结果等于target
目标和算法代码--c++
class Solution {
public:
int findTargetSumWays(vector<int>& nums, int target) {
int sum = 0;
for (int i = 0; i < nums.size(); i++) {
sum += nums[i];
}
int diff = sum - target;
if (diff < 0 || diff % 2 != 0) {
return 0;
}
int n = nums.size();
int neg = diff / 2;
// 数组综合sum,-元素之和为neg,则其余+元素之和为sum−neg,(sum−neg)−neg = target
vector<vector<int>> dp(n + 1, vector<int>(neg + 1));
/* dp数组初始化 */
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= neg; j++) {
dp[i][j] = dp[i - 1][j];
/* 如果背包剩余j的容量大于放的物品nums[i-1]则就可以将物品nums[i-1]放入背包中 */
if (j >= nums[i - 1]) {
dp[i][j] += dp[i - 1][j - nums[i - 1]];
}
}
}
return dp[n][neg];
}
};
目标和算法分析
状态定义。dp[i][j] = 在数组中选取元素,前i个数的和等于j;
列出状态转移方程。如果j >= nums,dp[i][j] = dp[i − 1][j] + dp[i − 1][j − num];如果j < nums,dp[i][j] = dp[i − 1][j];
初始化状态。dp[0][0] = 1。
区间算法
算法描述
将整个问题区间逐步拆分成小区间来处理。
算法举例--最长回文子序列定义
给定字符串s,找出最长回文子序列,并返回该序列长度。
算法举例--最长回文子序列复杂度
一般是O(n^2)
算法举例--最长回文子序列代码--c++
int longestPalindromeSubseq(string s) {
int n = s.size();
vector<vector<int>> dp(n, vector<int>(n, 0));
// base case
for (int i = 0; i < n; i++)
dp[i][i] = 1;
// 反着遍历保证正确的状态转移
for (int i = n - 1; i >= 0; i--) {
for (int j = i + 1; j < n; j++) {
// 状态转移方程
if (s[i] == s[j])
dp[i][j] = dp[i + 1][j - 1] + 2;
else
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
}
return dp[0][n - 1];
}
算法举例--最长回文子序列分析
状态定义。dp[i][j] = 最长回文子序列长度,数组s[i.......j]
列出状态转移方程。如果s[i] == s[j],dp[i][j] = dp[i + 1][j - 1] + 2;否则,dp[i][j] = max(dp[i − 1][j], dp[i][j - 1]);
初始化状态。dp[i][j] = 1。
树形算法
算法描述
dp动态规划应用在树状结构。
算法举例--二叉树最大路径和定义
二叉树中,路径即一条节点序列,序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中至多出现一次,该路径至少包含一个节点,且不一定经过根节点。路径和是路径中各节点值的总和。
算法举例--二叉树最大路径复杂度
算法举例--二叉树最大路径和代码
class Solution {
public:
int maxPathSum(TreeNode *root) {
int ans = INT_MIN;
function<int(TreeNode*)> dfs = [&](TreeNode *node) -> int {
if (node == nullptr)
return 0; // 没有节点,和为 0
int l_val = dfs(node->left); // 左子树最大链和
int r_val = dfs(node->right); // 右子树最大链和
ans = max(ans, l_val + r_val + node->val); // 两条链拼成路径
return max(max(l_val, r_val) + node->val, 0); // 当前子树最大链和
};
dfs(root);
return ans;
}
};
算法举例--二叉树最大路径和分析
当前节点【拐弯】最大路径和 = 左子树最大链和 + 右子树最大链和 + 当前节点值
如果值为负,返回0
数位算法
算法描述
顾名思义,dp动态规划应用在数位。
算法举例--最大为N的数字组合定义
给定非递减顺序排列的数字数组 digits
。用任意次数 digits[i]
来写数字。例如,如果 digits = ['1','3','5']
,我们可以写数字,如 '13'
, '551'
, 和 '1351315'
。返回可以生成的小于或等于n
的正整数的个数 。
算法举例--最大为N的数字组合复杂度
len为digits长度
算法举例--最大为N的数字组合代码
class Solution {
public:
int atMostNGivenDigitSet(vector<string> &digits, int n) {
auto s = to_string(n);
int m = s.length(), dp[m];
memset(dp, -1, sizeof(dp)); // dp[i] = -1 表示 i 这个状态还没被计算出来
function<int(int, bool, bool)> f = [&](int i, bool is_limit, bool is_num) -> int {
if (i == m) return is_num; // 如果填了数字,则为 1 种合法方案
if (!is_limit && is_num && dp[i] >= 0) return dp[i]; // 在不受到任何约束的情况下,返回记录的结果,避免重复运算
int res = 0;
if (!is_num) // 前面不填数字,那么可以跳过当前数位,也不填数字
// is_limit 改为 false,因为没有填数字,位数都比 n 要短,自然不会受到 n 的约束
// is_num 仍然为 false,因为没有填任何数字
res = f(i + 1, false, false);
char up = is_limit ? s[i] : '9'; // 根据是否受到约束,决定可以填的数字的上限
// 注意:对于一般的题目而言,如果这里 is_num 为 false,则必须从 1 开始枚举,由于本题 digits 没有 0,所以无需处理这种情况
for (auto &d : digits) { // 枚举要填入的数字 d
if (d[0] > up) break; // d 超过上限,由于 digits 是有序的,后面的 d 都会超过上限,故退出循环
// is_limit:如果当前受到 n 的约束,且填的数字等于上限,那么后面仍然会受到 n 的约束
// is_num 为 true,因为填了数字
res += f(i + 1, is_limit && d[0] == up, true);
}
if (!is_limit && is_num) dp[i] = res; // 在不受到任何约束的情况下,记录结果
return res;
};
return f(0, true, false);
}
};
算法举例--最大为N的数字组合分析
f(i, isLimit, isNum) = 从左往右第i位及其之后数位的合法方案;
isLimit为是否受n约束,如果为true,则至多为s[i],如果为false否则至多为9;
isNum表示是否填了数字,如果为true,必须填数字,从0开始,如果为false,跳过。