动态规划

动态规划

动态规划与分治方法相似，都是通过组合子问题的解来求解原问题；
分治方法将问题划分为互不相交的子问题，递归的求解子问题，再将它们的解组合起来，求解原问题的解。
与之相反，动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题，而这些公共的子子问题不需要反复递归求解，动态规划算法对每个子子问题只求解一次。

带备忘的自上向下

即将子子问题求解一次后，备份存储，便于下次需要时，直接使用即可。
这种方法，提供了求解子问题的效率，避免了重复求解。空间复杂度为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的最小代价。

1. 动态规划：dp[i][j]表示word1的前i个字符编辑成word2的前j个字符需要的最小操作数
2. 初始状态：dp[i][0] = i，i次删除；dp[0][i] = i，i次插入
3. 过渡公式：

• 当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

1. 二维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];
    }
};

2. 一维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];
    }
};