动态规划-leetcode小结

动态规划思路小结：
首先我们要决定要存储什么历史信息以及用什么数据结构来存储信息。然后是最重要的递推式，就是如从存储的历史信息中得到当前步的结果。最后我们需要考虑的就是起始条件的值。
求解的基本步骤

（1）从子问题入手，分析最优解的性质，定义子问题变量
（2）分析最优解的性质，定义递归最优解公式。
（3）以自底向上计算出最优值或者自顶向下的记忆化方式（即备忘录法），注意初始化和得到最优解。

10. Regular Expression Matching

实现包括.或者*
思路一：考虑第二个字符是否为*

class Solution {
public:
    bool isMatch(string s, string p) {
        if (p.empty())
            return s.empty();

        if (p.size() > 1 && p[1] == '*')
            return isMatch(s, p.substr(2)) || (!s.empty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substr(1), p));
        else 
            return !s.empty() && (s[0] == p[0] || p[0] == '.') && isMatch(s.substr(1), p.substr(1));
    }
};

思路二：动态规划

class Solution {
public:
    bool isMatch(string s, string p) {
        /**
         * f[i][j]: if s[0..i-1] matches p[0..j-1]
         * if p[j - 1] != '*'
         *      f[i][j] = f[i - 1][j - 1] && s[i - 1] == p[j - 1]
         * if p[j - 1] == '*', denote p[j - 2] with x
         *      f[i][j] is true iff any of the following is true
         *      1) "x*" repeats 0 time and matches empty: f[i][j - 2]
         *      2) "x*" repeats >= 1 times and matches "x*x": s[i - 1] == x && f[i - 1][j]
         * '.' matches any single character
         */
        int m = s.size(), n = p.size();
        vector<vector<bool>> f(m + 1, vector<bool>(n + 1, false));

        f[0][0] = true;
        for (int i = 1; i <= m; i++)
            f[i][0] = false;
        // p[0.., j - 3, j - 2, j - 1] matches empty iff p[j - 1] is '*' and p[0..j - 3] matches empty
        for (int j = 1; j <= n; j++)
            f[0][j] = j > 1 && '*' == p[j - 1] && f[0][j - 2];

        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                if (p[j - 1] != '*')
                    f[i][j] = f[i - 1][j - 1] && (s[i - 1] == p[j - 1] || '.' == p[j - 1]);
                else
                    // p[0] cannot be '*' so no need to check "j > 1" here
                    f[i][j] = f[i][j - 2] || (s[i - 1] == p[j - 2] || '.' == p[j - 2]) && f[i - 1][j];

        return f[m][n];
    }
};

118. Pascal’s Triangle

给出杨辉三角的前n行元素

For example, given numRows = 5,

二维数组的声明上：

result[i].resize(i+1);//方法一
vector<int> tmpres;
tmpres.resize(i+1);  
result.push_back(tmpres);//方法二  

每一行左右两侧为1，中间元素是上一行对应位置的两个数之和
主要是要注意代码的简洁高效：

class Solution {
public:
    vector<vector<int>> generate(int numRows) {

    vector<vector<int>> res(numRows);
    for (int i = 0; i < numRows; ++i){
        res[i].resize(i+1);
        res[i][0] = res[i][i] = 1;
        for (int j = 1; j < i; ++j)
            res[i][j] = res[i-1][j-1] + res[i-1][j];
    }
        return res;
    }
};

119. Pascal’s Triangle II

给出杨辉三角的第n行元素（n从0开始）

主要是注意代码的时间和空间复杂度，不要受到上一题的影响，还用二维数组去处理，找到规律用一维数组即可。下面是参考别人的写法，复杂度是O(k);

class Solution {
public:
    vector<int> getRow(int rowIndex) {
    vector<int> res(rowIndex+1, 0);
    res[0] = 1;
    for (int i = 1; i <= rowIndex; ++i){
        for (int j = i; i >= 1; --j) 
            res[j] += res[j-1];
    }
    return res;   
    }
};

63. Unique Paths II

这一题是有障碍的路径移动，注意有障碍的地方不能到达，尤其是在初始化的时候，障碍物在边界上的情况。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if (obstacleGrid.empty()) return 0;
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        int dp[m][n] = {0};   
        dp[0][0]= obstacleGrid[0][0] == 1 ? 0 : 1;//初始化一定呀正确，不能忽略了某些情况
        //初始化动态数组
        for (int i = 1; i < m; ++i) {
            if (obstacleGrid[i][0]) dp[i][0] = 0;
            else dp[i][0] = dp[i-1][0];//由上一次来推到 
        }
        for (int i = 1; i < n; ++i) {
            if (obstacleGrid[0][i]) dp[0][i] = 0;
            else dp[0][i] = dp[0][i-1];//由上一次来推到 
        }
        if (m == 1 || n == 1) return dp[m-1][n-1];
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j)
                if (obstacleGrid[i][j]) dp[i][j] = 0;//有障碍的地方不能到达
                else dp[i][j] = dp[i-1][j] + dp[i][j-1];//每个位置可以从上或者从右到达
        }
        return dp[m-1][n-1];    
    }
};

修改版：https://leetcode.com/problems/unique-paths-ii/?tab=Solutions

72. Edit Distance

求从一个字符串转变到另一个字符串需要的变换步骤，共有三种变换方式，插入一个字符，删除一个字符，和替换一个字符。
这道题我们需要维护一个二维的数组dp，其中dp[i][j]表示从word1的前i个字符转换到word2的前j个字符所需要的步骤。那我们可以先给这个二维数组dp的第一行第一列赋值，这个很简单，因为第一行和第一列对应的总有一个字符串是空串，于是转换步骤完全是另一个字符串的长度。当word1[i] == word2[j]时，dp[i][j] = dp[i - 1][j - 1]，其他情况时，dp[i][j]是其左，左上，上的三个值中的最小值加1。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n1 = word1.size(), n2 = word2.size();
        vector<vector <int>>dp(n1+1, vector<int>(n2+1,0));
        for (int i = 0; i <= n1; i++) dp[i][0] = i;
        for (int i = 0; i <= n2; i++) dp[0][i] = i;
        for (int i = 1; i <= n1; i++) {
            for (int j = 1; j <= n2; j++) 
                if (word1[i-1] == word2[j-1])
                    dp[i][j] = dp[i-1][j-1];
                else
                    dp[i][j] = min(dp[i-1][j-1], min(dp[i][j-1], dp[i-1][j])) + 1;
        }
        return dp[n1][n2];
    }
};

97. Interleaving String

思路：如果s3是s1和s2的交叉形成，那s3的子串也是…重复这个过程，满足最优子结构和子问题重叠的条件，所以用动态规划求解。维护一个二维的动态数组，判断当s1在位置I，当s2在位置J处，s3在位置i+j上是否是交叉的。
递推公式：
dp[i][j] = ( dp[i][j-1] && s3[i+j-1] == s2[j-1]) || ( dp[i-1][j] && s3[i+j-1] == s1[i-1])。
注意初始化的时候从0开始，在位置i表示的是从0到i-1的字符串。所以边界条件要多加1.

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
       if(s3.length() != s1.length() + s2.length()) return false;
       vector <vector <bool>> dp(s1.size() + 1, vector <bool>(s2.size() + 1));
       //DP table represents if s3 is interleaving at (i+j)th position when s1 is at ith position, and s2 is at jth position. 
       for (int i = 0; i < s1.size() + 1; ++i) {
           for (int j = 0; j < s2.size() + 1; ++j) {
               if (i == 0 && j ==0) dp[0][0] = true;//0th position means empty string.
               else if (i==0) dp[0][j] = dp[0][j-1] && s3[j-1] == s2[j-1];
               else if (j==0) dp[i][0] = dp[i-1][0] && s3[i-1] == s1[i-1];
               else dp[i][j] =  ( dp[i][j-1] && s3[i+j-1] == s2[j-1]) || ( dp[i-1][j] && s3[i+j-1] == s1[i-1]);
           }    
       }
       return dp[s1.size()][s2.size()];
    }
};

139. Word Break

给出一个非空字符串s和一个非空词典，判断字符串s是否可以被空格切分成一个或多个出现在字典中的单词。
思路：首先我们要存储的历史信息res[i]是表示到字符串s的第i个元素为止能不能用字典中的词来表示，我们需要一个长度为n的布尔数组来存储信息。然后假设我们现在拥有res[0,…,i-1]的结果，我们来获得res[i]的表达式。思路是对于每个以i为结尾的子串，看看他是不是在字典里面以及他之前的元素对应的res[j]是不是true，如果都成立，那么res[i]为true。

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_map<string, bool> words;
        for (auto w : wordDict) {
            words[w] = true;
        }
        int len = s.size();
        vector<bool> res(len + 1, false);
        res[0] = true;
        for (int i = 0; i < len + 1; ++i) {
            for (int j = 0; j < i; ++j) {
                if (res[j] && words.find(s.substr(j, i-j)) != words.end()) {
                    res[i] = true;
                    break;
                }
            }
        }
        return res[len];
    }
};

516. Longest Palindromic Subsequence

最长的子序列，状态变量定义dp[i[j]表示从i到j的字符串中最长回文序列。
初始化：i==j, i+1==j两种
状态转移：根据s[i] == s[j] 决定
注意：subsequence和substring的区别，subsequence是说自序列，只要字母的前后顺序没有变都可以组合在一起，substring是子字符串，那就是要连一起的，相邻的那才叫子字符串。

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        if (s.empty()) return 0;
        int sLen = s.size();
        vector<vector<int>> arr(sLen, vector<int>(sLen,0));
        for (int l = 1; l <= sLen; ++l){
            for (int i = 0; i + l <= sLen; ++i){
                int j = i + l - 1;
                if (j == i) arr[i][j] = 1;
                else if (j == i+1) arr[i][j] = (s[i] == s[j]) ? 2 : 1;
                else {
                    if (s[i] == s[j]) arr[i][j] = arr[i+1][j-1] + 2;
                    else arr[i][j] = max(arr[i+1][j], arr[i][j-1]); 
                }
            }
        }
        return arr[0][sLen-1];
    }
};