day56 编辑距离

392.判断子序列
题目
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

按照顺序 — 双指针

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int m = s.length(), n = t.length();
        int i = 0, j = 0;
        while (i < m && j < n) {
            if (s[i] == t[j]) {
                i++;
            }
            j++;
        }
        return i == m;
    }
};

动态规划

dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度
if(s[i-1] == t[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];

递推公式与公共子序列非常的相似，但是因为是判断s是不是t的子序列 所以 能够删除的只有t 而公共子序列是两个都能删除取max

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

115. 不同的子序列
题目：给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数。问种类问题

情况一： 当前字符不相等，那么需要删除s中的字符，那么
dp[ i ][ j ] = dp[ i ][ j-1 ]
情况二：当前字符相等，可以选择要，也可选择不要
dp[ i ][ j ] = dp[ i-1 ][ j-1 ] + dp[ i ][ j-1 ]

初始化：

1. 题目数据保证答案符合 32 位带符号整数范围
   –》 vector>dp(n+1, vector(m+1, 0));
   int 会越界
2. t字符串为空，种类数为1

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

583. 两个字符串的删除操作
题目：给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。 最小步数

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

递推公式
情况一：不相等
删掉word1 或者 word2的一个字符 看min
dp[ i ][ j ] = min(dp[ i ][ j-1 ], dp[ i-1 ][ j ]) + 1
上面那种情况包含了两个单词都删字符 只不过是下一步

情况二：相等 不删
dp[ i ][ j ] = dp[ i-1 ][ j-1 ]

初始化：
for(int i=0; i<=n; i++) dp[i][0] = i;
for(int j=0; j<=m; j++) dp[0][j] = j;

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

72. 编辑距离
题目：给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。 只能删除word1 不能动 word2.
你可以对一个单词进行如下三种操作：
插入一个字符 删除一个字符 替换一个字符

递推公式：
情况一：两个字符相等
dp[ i ][ j ] = dp[ i-1 ][ j-1 ]
情况二：两个字符不相等 + 最少操作 = min
删除word1字符 dp[ i ][ j ] = dp[ i ][ j-1 ] + 1
插入一个字符，相当于word2删除这个字符 dp[ i ][ j ] = dp[ i-1 ][ j ] + 1
（在word1加入一个字符就跟当前word2指向的字符相等了，两个字符消去之后就是看 dp[ i-1 ][ j ]， 就是word2删除这个字符 ）
替换字符使得两个字符相等 dp[ i ][ j ] = dp[ i-1 ][ j-1 ]+1

初始化：
for(int i=0; i<=n; i++) dp[i][0] = i;
for(int j=0; j<=m; j++) dp[0][j] = j;

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