动态规划：72. 编辑距离

72. 编辑距离

题目要求：

 

解题思路：

 根据动态规划的步骤：

1. 定义数组元素的含义，这里用到两个字符串，所以应该定义二维数组；

由于我们求的是字符串1转换成字符串2所需要的最少次数：当字符串1的长度为i，字符串2的长度为j，则字符串1转换成字符串2所需次数为dp[i][j];

2. 找出关系数组之间的关系式；

大部分情况下， dp[i] [j] 和 dp[i-1] [j]、 dp[i] [j-1]、 dp[i-1] [j-1] 肯定存在某种关系。

这里题目也给出了提示：插入，删除，替换操作

大体上分三种情况：

1）替换的情况：当word1中的前i-1个就可以变换为word2中的前j-1个，那么我们只要根据word1中的第i个是否等于word2中的第j个字符进行判断，

如果相等，那么cost[i][j]=cost[i-1][j-1];  否则，cost[i][j]=cost[i-1][j-1]+1,加的1就是我们将word1中第i个字符替换为word2中第j个的消耗。

2）删除的情况：当word1中的前i-1个就可以变换为word2中的前j个时，我们需要将word1中的第i个字符删除，cost[i][j]=cost[i-1][j]+1；

3）增加的情况：当word1中的前i个可以变换为word2中的前j-1个时，我们需要将word1中的第i个字符后面增加一个，cost[i][j]=cost[i][j-1]+1；

所以，我们的cost[i][j]取上列的最小值即可。

 

class Solution {
public:
    int minDistance(string word1, string word2) 
    {
        int m = word1.length();
        int n = word2.length();
        int dp[m+1][n+1];　　　　　　//相对下面两个，比较省内存
        //vector<vector<int>>dp(m+1,vector<int>(n+1,0));  //非常耗内存
        //动态申请数组二维dp  大小：(m+1)*(n+1)　　　　　　　　　//耗内存
        // int **dp = new int*[m+1]; 
        // for(int i=0; i<=m; i++) 
        // {
        //     dp[i] = new int[n+1];
        // }
        dp[0][0] = 0;
        for (int i=1; i <= m; i++)
        {
            //dp[i][0] = dp[i-1][0] + 1;
            dp[i][0] = i;
        }  
        for (int i=1; i <= n; i++)
        {
            //dp[0][i] = dp[0][i-1] + 1;
            dp[0][i] = i;
        }  
        for (int i=1; i <= m; i++)
        {
            for (int j=1; j <= n; j++)
            {           
                //strcmp(word1.c_str(),word2.c_str())
                if (word1[i-1]==word2[j-1])
                {
                    dp[i][j] = dp[i-1][j-1];
                }
                else 
                {
　　　　　　　　　　　　　　//无需手动写函数，直接使用C++中自动的宏定义：#define min(a,b) ( ((a)>(b)) ? (b):(a) ) 
                    dp[i][j]=min(min(dp[i-1][j-1], dp[i][j-1] ), dp[i-1][j] ) + 1;
                }
            }
        }
        return dp[m][n];
    }

    // int mindata(int a, int b)
    // {
    //     return ((a > b)? b:a);
    // }
};

 

 

动态规划的优化：

解题思路：一定要画图（矩阵图），看哪些网格可以替换，从而将二维数组转变成一维数组。

根据公式：dp[j] = min( min(dp[j-1], dp[j]), pre) + 1; 

每次计算dp[i][j]时用到三个网格，分别是（i-1，j-1），（i-1，j）和 （i，j-1），这时最多只需要i-1行网格，那么通过临时变量将（i-1，j-1）保存，并且每次将计算结果（i，j）更新到（i-1，j）中。

 

 

class Solution {
public:
    int minDistance(string word1, string word2) 
    {
        int m = word1.length();
        int n = word2.length();
        int dp[n+1];
        //vector<vector<int>>dp(m+1,vector<int>(n+1,0));
        //动态申请数组二维dp  大小：(m+1)*(n+1)
        // int **dp = new int*[m+1]; 
        // for(int i=0; i<=m; i++) 
        // {
        //     dp[i] = new int[n+1];
        // }
        //dp[0] = 0;
        for (int i=0; i <= n; i++)
        {
            dp[i] = i;
        } 
        for (int i=1; i <= m; i++)
        {
            int tmp = dp[0];
            dp[0] = i;       
            for (int j=1; j <= n; j++)
            {
                int pre = tmp;      //需要计算的值
                tmp = dp[j];        //在数据覆盖之前，先保存
                if (word1[i-1]==word2[j-1])
                {
                    dp[j] = pre;
                }
                else
                {
                    dp[j] = min( min(dp[j-1], dp[j]),  pre) + 1;
                } 
            }
        } 
        return dp[n];
    }
};