算法系列——动态规划11

class Solution {

public:

    int minDistance(string word1, string word2) {

        /*  dp[i][j]数组：以word1[i-1]结尾的字符串转化为word2[j-1]结尾的字符串所需的最小操作数

            如果两个字符相等： 就不需要任何操作 dp[i][j]=dp[i-1]dp[j-1];

            如果两个字符不相等：

            1：替换：dp[i][j]=dp[i-1]dp[j-1]+1;

            2：删除：dp[i][j]=dp[i-1][j]+1;

            3：添加：dp[i][j]=dp[i][j-1]+1;

                    ""    h    o   r   s   e

            ""      0     1    2   3   4   5   

            r       1    *1    2  (2)  3   4

            o       2     2  *(1) *2   3   4

            s       3     3    2   2  *(2) *3

            带*是它的操作步骤：

            1.将‘h’替换成‘r’;

            2.将‘o’不动;

            3.将‘r’删除;

            4.将‘s’不动;

            5.将‘e’删除;                              

            带括号的就是两个字符相等，word1[i-1]==word2[j-1]

            就什么也不做,即不会增加操作数，此时的状态只能来自于dp[i-1][j-1],就是看word1[i-2]和word2[i-2]相不相等：

            dp[i][j]=dp[i-1][j-1];

            替换：此时word1比word2字符数量上相同的，最后一个字符不同，需要进行替换操作，此时操作数+1，

            此时的状态只能来自于dp[i-1][j-1]，所以dp[i][j]=dp[i-1][j-1]+1

            删除：此时word1比word2多一个字符 需要将word1的第i-1个字符删除一个得到word2,此时操作数+1，

            所以dp[i][j]=d[i-1][j]+1;

            添加：此时word1比word2少一个字符 相当于word2比word1多一个字符，即还是删除操作，此时操作数+1，

            所以dp[i][j]=dp[i][j-1]+1

        */

        int m=word1.size();

        int n=word2.size();

        vector<vector<int>>dp(m+1,vector<int>(n+1));

        dp[0][0]=0;

        for(int i=1;i<m+1;i++){

            dp[i][0]=i;

        }

        for(int i=1;i<n+1;i++){

            dp[0][i]=i;

        }

        for(int i=1;i<dp.size();i++){

            for(int j=1;j<dp[0].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],min(dp[i-1][j],dp[i][j-1]))+1;

            }

        }

        return dp[m][n];

    }

};