动态规划
动态规划与分治方法相似,都是通过组合子问题的解来求解原问题;
分治方法将问题划分为互不相交的子问题,递归的求解子问题,再将它们的解组合起来,求解原问题的解。
与之相反,动态规划应用于子问题重叠的情况,即不同的子问题具有公共的子子问题,而这些公共的子子问题不需要反复递归求解,动态规划算法对每个子子问题只求解一次。
带备忘的自上向下
即将子子问题求解一次后,备份存储,便于下次需要时,直接使用即可。
这种方法,提供了求解子问题的效率,避免了重复求解。空间复杂度为O(n), 用以备忘每个子问题的解。
自底向上递归
空间复杂度O(1), 时间复杂度O(n)
由于任何子问题都只依赖于更小的子问题的求解。因而我们从规模最小的子问题开始向上求解。当求解某个子问题时,他所依赖的那些更小的子问题都已经求解完毕,结果也已经保存。
示例
跳台阶
一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。
核心是要找到状态转移方程, 即递推公式,本题的递推公式是:
由于每次只能跳1级或者2级,那么对于n级台阶,要么最后跳1级到达n级,要么最后跳2级到达n级。所以该问题可以拆分为,跳n级台阶的跳法种数等于跳n-1级的跳法种数加上跳n-2级的跳法种数,即f(n) = f(n - 1) + f(n - 2);
采用一维dp数组:
class Solution {
public:
int climbStairs(int n) {
vector<int> dp(n + 1, -1);
dp[1] = 1;
dp[0] = 1;
for(int i = 2; i <= n; ++i)
{
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
};
采用滚动数组优化递推公式:
class Solution {
public:
int climbStairs(int n) {
int p = 0, q = 0, r = 1;
for (int i = 1; i <= n; ++i) {
p = q;
q = r;
r = p + q;
}
return r;
}
};
LCS(最长公共子串)
给定两个字符串str1和str2,输出两个字符串的最长公共子串
题目保证str1和str2的最长公共子串存在且唯一。
示例1
输入
"1AB2345CD","12345EF"
返回值
"2345"
class Solution {
public:
/**
* longest common substring
* @param str1 string字符串 the string
* @param str2 string字符串 the string
* @return string字符串
*/
string LCS(string str1, string str2) {
// write code here
string res;
int dp[str1.length() + 1][str2.length() + 1];
for(int i = 0; i <= str1.length(); ++i)
{
dp[i][0] = 0;
}
for(int j = 0; j <= str2.length(); ++j)
{
dp[0][j] = 0;
}
int max_len = 0, end = 0;
for(int i = 1; i <= str1.length(); ++i)
{
for(int j = 1; j <= str2.length(); ++j)
{
if(str1[i - 1] == str2[j - 1])
{
dp[i][j] = dp[i - 1][j - 1] + 1;
}
else dp[i][j] = 0;
if(dp[i][j] > max_len)
{
max_len = dp[i][j];
end = i - 1;
}
}
}
if(max_len == 0) return res;
res = str1.substr(end - max_len + 1, max_len);
return res;
}
};
最长回文子串
参考思路
最长回文子串
- 中心扩散法:
class Solution {
public:
int getLongestPalindrome(string A, int n) {
// write code here
if (n < 2)
return A.length();
int max_len = 0;
for(int i = 0; i < n;)
{
// 如果剩余子串长度小于目前查找到的最长回文子串的长度,直接终止循环
// (因为即使他是回文子串,也不是最长的,所以直接终止循环,不再判断)
if (n - i <= max_len / 2)
break;
int left = i, right = i;
while(right < n - 1 && A.at(right + 1) == A.at(i))
right++; // 过滤掉重复的
i = right + 1; //下次在判断的时候从重复的下一个字符开始判断
while(left > 0 && right < n - 1 &&
A.at(left - 1) == A.at(right + 1))
{
left--;
right++;
}
max_len = std::max(max_len, right - left + 1);
}
return max_len;
}
};
- 动态规划
class Solution {
public:
int getLongestPalindrome(string A, int n) {
// write code here
if (n < 2)
return A.length();
vector<vector<bool>> dp(n, vector<bool>(n, false));
int max_len = 0;
for(int right = 1; right < n; ++right)
{
for(int left = 0; left < right; ++left)
{
if(A[left] == A[right])
{
if(right - left <= 2)
{
dp[left][right] = true;
}
else
{
dp[left][right] = dp[left+1][right-1];
}
if(dp[left][right])
{
max_len = std::max(max_len, right - left + 1);
}
}
}
}
return max_len;
}
};
最小编辑代价
给定两个字符串str1和str2,再给定三个整数ic,dc和rc,分别代表插入、删除和替换一个字符的代价,请输出将str1编辑成str2的最小代价。
- 动态规划:dp[i][j]表示word1的前i个字符编辑成word2的前j个字符需要的最小操作数
- 初始状态:dp[i][0] = i,i次删除;dp[0][i] = i,i次插入
- 过渡公式:
- 当i字符等于j字符时:dp[i][j] = dp[i-1][j-1],不需要额外操作
- 当i字符不等于j字符时:dp[i][j] = Math.min(insert, delete, replace)
- int insert = dp[i][j-1] + 1; i个编辑成j-1个字符,再插入一个j
- int delete = dp[i-1][j] + 1; i-1个编辑成j个字母,再删除一个i
- int replace = dp[i-1][j-1] + 1; i-1个编辑成j-1个字母,再将i替换成j
class Solution {
public:
/**
* min edit cost
* @param str1 string字符串 the string
* @param str2 string字符串 the string
* @param ic int整型 insert cost
* @param dc int整型 delete cost
* @param rc int整型 replace cost
* @return int整型
*/
int minEditCost(string str1, string str2, int ic, int dc, int rc) {
// write code here
int cost[str1.length() + 1][str2.length() + 1];
for(int i = 0; i <= str1.length(); ++i)
{
// i个字符变成0个字符, 删除即可
cost[i][0] = dc * i;
}
for(int j = 0; j <= str2.length(); ++j)
{
// 0个字符变成j个字符, 插入即可
cost[0][j] = ic * j;
}
for(int i = 1; i <= str1.length(); ++i)
{
for(int j = 1; j <= str2.length(); ++j)
{
if(str1.at(i - 1) == str2.at(j - 1))
{
cost[i][j] = cost[i - 1][j - 1];
}
else
{
// 删除代价:
auto del = dc + cost[i - 1][j];
// 插入代价
auto insert = ic + cost[i][j - 1];
// 替换代价
auto replace = rc + cost[i - 1][j - 1];
cost[i][j] = min(insert, min(del, replace));
}
}
}
return cost[str1.length()][str2.length()];
}
};
矩阵的最小路径和
- 题目描述
给定一个 n * m 的矩阵 a,从左上角开始每次只能向右或者向下走,最后到达右下角的位置,路径上所有的数字累加起来就是路径和,输出所有的路径中最小的路径和。 - 示例1
- 输入
[[1,3,5,9],[8,1,3,4],[5,0,6,1],[8,8,4,0]] - 返回值
12
- 输入
解题思路:
核心是找到一般结构的最优解递归式:
f(n,m)矩阵的最短路径:
f(n,m) = std::min{f(n - 1, m) + a[n][m], f(n, m - 1) + a[n][m]};
class Solution {
public:
/**
*
* @param matrix int整型vector<vector<>> the matrix
* @return int整型
*/
int minPathSum(vector<vector<int> >& matrix) {
// write code here
int rows = matrix.size();
if(rows < 1)
return 0;
int cols = matrix.at(0).size();
if(cols < 1)
return 0;
vector<vector<int>> dp(rows, vector<int>(cols, 0));
dp[0][0] = matrix[0][0];
for(int i = 1; i < rows; ++i)
{
dp[i][0] = dp[i - 1][0] + matrix[i][0];
}
for(int j = 1; j < cols; ++j)
{
dp[0][j] = dp[0][j - 1] + matrix[0][j];
}
for(int i = 1; i < rows; ++i)
{
for(int j = 1; j < cols; ++j)
{
dp[i][j] = std::min(dp[i][j - 1] + matrix[i][j],
dp[i - 1][j] + matrix[i][j]);
}
}
return dp[rows - 1][cols - 1];
}
};
01背包
已知一个背包最多能容纳物体的体积为V
现有n个物品第i个物品的体积为vi
第i个物品的重量为wi
求当前背包最多能装多大重量的物品
- 示例1
- 输入
10,2,[[1,3],[10,4]] - 返回值
4
- 二维dp
dp[i][j]: 对于前i个物品,当前背包的容量为j时,这时候能装下的最大价值是dp[i][j]
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
* 计算01背包问题的结果
* @param V int整型 背包的体积
* @param n int整型 物品的个数
* @param vw int整型vector<vector<>> 第一维度为n,第二维度为2的二维数组,vw[i][0],vw[i][1]分别描述i+1个物品的vi,wi
* @return int整型
*/
int knapsack(int V, int n, vector<vector<int> >& vw) {
// write code here
// dp[i][j]: 对于前i个物品,当前背包的容量为j时,这时候能装下的最大价值是
// dp[i][j]
std::vector<vector<int>> dp(n + 1, vector<int>(V + 1, 0));
int w_max = 0;
for(int i = 1; i <= n; ++i)
{
for(int j = 1; j <= V; ++j)
{
if(vw[i-1][0] <= j)
{
dp[i][j] = std::max(dp[i - 1][j - vw[i-1][0]] + vw[i-1][1],
dp[i-1][j]);
}
else
{
// 装不下了
dp[i][j] = dp[i-1][j];
}
}
}
return dp[n][V];
}
};
- 一维dp方案
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
* 计算01背包问题的结果
* @param V int整型 背包的体积
* @param n int整型 物品的个数
* @param vw int整型vector<vector<>> 第一维度为n,第二维度为2的二维数组,vw[i][0],vw[i][1]分别描述i+1个物品的vi,wi
* @return int整型
*/
int knapsack(int V, int n, vector<vector<int> >& vw) {
// write code here
// dp[j]表明是针对所有物品,当容量为j时的最大重量
std::vector<int> dp(V + 1, 0);
for(int i = 0; i < n; i++)
{
for(int j = V; j >= vw[i][0]; j--)
{
// 表明装的下
dp[j] = std::max(dp[j], dp[j - vw[i][0]] + vw[i][1]);
}
}
return dp[V];
}
};