力扣题解 动态规划（7）

115.不同的子序列

遍历顺序 从上到下 从左到右。

uint8_t，uint16_t，uint32_t等都不是什么新的数据类型，它们只是使用typedef给类型起的别名。

错误 for (int j = 1; j < t.size(); j++) dp0 = 0;

j = 1,开始 定义第一行第一列 已经上面这行代码初始化为 1了。剩下的为0.

  class Solution {
    
    public:
        int numDistinct(string s, string t) {
    
            vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
            for (int i = 0; i < s.size(); i++) dp[i][0] = 1;
            for (int j = 1; j < t.size(); j++) dp[0][j] = 0;
            for (int i = 1; i <= s.size(); i++) {
    
                for (int j = 1; j <= t.size(); j++) {
    
                    if (s[i - 1] == t[j - 1]) {
    
                        dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                    } else {
    
                        dp[i][j] = dp[i - 1][j];
                    }
                }
            }
            return dp[s.size()][t.size()];
        }
    };

583. 两个字符串的删除操作

总结：解法一

dp i ：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。

一定要区分 相等和不相等的时候

错误： 最后的for 循环的时候 要小于等于 ，第二个，如果min三个比较的话要加大括号。

  class Solution {
    
    public:
        int minDistance(string word1, string word2) {
    
            vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));
            for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
            for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
            for (int i = 1; i <= word1.size(); i++) {
    
                for (int j = 1; j <= word2.size(); 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] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});
                    }
                }
            }
            return dp[word1.size()][word2.size()];
        }
    };

解法二：

本题和动态规划：1143.最长公共子序列 (opens new window)基本相同，只要求出两个字符串的最长公共子序列长度即可，那么除了最长公共子序列之外的字符都是必须删除的，最后用两个字符串的总长度减去两个最长公共子序列的长度就是删除的最少步数。

代码如下：

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

72. 编辑距离

总结：

dpi 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dpi。

那么dpi就应该是i，对word1里的元素全部做删除操作，即：dpi = i;

 class Solution {
    
    public:
        int minDistance(string word1, string word2) {
    
            vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
            for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
            for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
            for (int i = 1; i <= word1.size(); i++) {
    
                for (int j = 1; j <= word2.size(); 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], dp[i - 1][j], dp[i][j - 1]}) + 1;
                    }
                }
            }
            return dp[word1.size()][word2.size()];
        }
    };

647. 回文子串

class Solution {
    
public:
    int countSubstrings(string s) {
    
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int result = 0;
        for (int i = s.size() - 1; i >= 0; i--) {
    
            for (int j = i; j < s.size(); j++) {
    
                if (s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])) {
    
                    result++;
                    dp[i][j] = true;
                }
            }
        }
        return result;
    }
};

• 时间复杂度：O(n^2)
• 空间复杂度：O(n^2)

另解：双指针

   class Solution {
    
    public:
        int countSubstrings(string s) {
    
            int result = 0;
            for (int i = 0; i < s.size(); i++) {
    
                result += extend(s, i, i, s.size()); // 以i为中心
                result += extend(s, i, i + 1, s.size()); // 以i和i+1为中心
            }
            return result;
        }
        int extend(const string& s, int i, int j, int n) {
    
            int res = 0;
            while (i >= 0 && j < n && s[i] == s[j]) {
    
                i--;
                j++;
                res++;
            }
            return res;
        }
    };

516.最长回文子序列

总结：第一次斜对角的相等已经加1 了 单个肯定是回文，所以第二个循环从 j = i + 1;第二个开始判断。

  class Solution {
    
    public:
        int longestPalindromeSubseq(string s) {
    
            vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
            for (int i = 0; i < s.size(); i++) dp[i][i] = 1;
            for (int i = s.size() - 1; i >= 0; i--) {
    
                for (int j = i + 1; j < s.size(); 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][s.size() - 1];
        }
    };