力扣刷题题解注意(10

力扣72编辑距离

本题难点在于如何定义dp数组，dp数组的含义是什么？以前对于dp数组都是针对一个对象（字符串或者背包重量价值），而本题对于dp数组是针对两个对象，dp[i][j]代表的含义是word1从0~i-1，word2从0~j-1最小的操作数是多少。

其次就是递推公式，对于递推公式，我们假设的前提是word[i-1]是否和word[j-1]相等，如果相等的话那么他们的最小操作数的值就是dp[i-1][j-1]；word[i-1][j-1]如果不相等的话，那么就要考虑使他们相等之后会存在的情况：插入word1（删除word2）、还是插入word2（删除word1）、替换word1，这三种情况分别对应的是dp[i][j-1]，dp[i-1][j]，dp[i-1][j-1]。

对于遍历顺序，由于之前的值都在左上方，要保证左上方的值被初始化了

dp[i][0]代表的含义是word1中0到i-1与word2中-1相差几个操作数，这里的-1本质上就是空串，所以操作数最小是i。dp[0][j]同理。

int minDistance(string word1, string word2) {
        int m=word1.size();
        int n=word2.size();
        int dp[m+1][n+1];//定义dp数组为word1从0到i-1 与 word2从0到j-1的最小操作数
        //初始化
        for(int i=0;i<=m;++i)
        {
            dp[i][0]=i;//表示空串和0-i-1之间删除i次
        }
        for(int j=0;j<=n;++j)
        {
            dp[0][j]=j;//表示空串和0-i-1之间删除i次
        }
        //遍历
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=n;++j)
            {
                if(word1[i-1]==word2[j-1])//最小操作数长度word1从0~i-1，word2从0~j-1长度
                {
                    dp[i][j]=dp[i-1][j-1];
                }
                else
                {
                    dp[i][j]=1+min(min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1]);//最小操作数长度来自于删除插入替换
                }
            }
        }
        return dp[m][n];
    }

力扣583两个字符串删除操作

类似上题，直接ac

int minDistance(string word1, string word2) {
        int m=word1.length();
        int n=word2.length();
        int dp[m+1][n+1];
        for(int i=0;i<=m;++i)
        {
            dp[i][0]=i;//和空串相等需要多少次删除
        }
        for(int j=0;j<=n;++j)
        {
            dp[0][j]=j;
        }
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=n;++j)
            {
                if(word1[i-1]==word2[j-1])
                {
                    dp[i][j]=dp[i-1][j-1];
                }
                else
                {
                    dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+2);
                }
            }
        }
        return dp[m][n];
    }

力扣115不同的子序列

1.思路与前面的字符串操作类似，dp数组定义也是类似的，不过是s和t中截止到i-1和j-1有多少子序列，“多少”也就是求和问题。

2.递推公式思路类似前面，也是以s[i-1]与t[j-1]为选择点。需要注意的是，动态规划中关于字符串的问题都要定义的是i-1与j-1，也就是说定义dp数组要等于size+1，并且由于是求t在s中有多少子序列，所以要考虑s中的某个字符有无的问题。

3.本题中题目说了要取模，所以暗示了题目数据量之大，最开始用int（4Byte）类型无法AC，换成long（有符号8Byte）也无法AC，最后换成uint64_t（无符号8Byte）才得以AC。

int numDistinct(string s, string t) {
        int m=s.size(),n=t.size();
        // int dp[m+1][n+1];//0~i-1与0~j-1有多少子序列
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
        // vector<vector<long>> dp(s.size() + 1, vector<long>(t.size() + 1));
        //uint64_t 64位无符号整数类型定义
        for(int i=0;i<m;++i)
        {
            dp[i][0]=1;//肯定能从子序列中找到一个空集
        }
        for(int j=1;j<n;++j)
        {
            dp[0][j]=0;
        }
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=n;++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[m][n];
    }