lintcode---编辑距离I与编辑距离II

编辑距离I：
题目描述：
给出两个单词word1和word2，计算出将word1 转换为word2的最少操作次数。

你总共三种操作方法：
1.插入一个字符
2.删除一个字符
3.替换一个字符

样例：
样例
给出 work1=”mart” 和 work2=”karma”
返回 3

思路讲解：根据标签是动态规划，我考虑利用动态规划来求解，做动态规划的重点是找到状态转移方程，
假设字符序列A[1…i] 、B[1…j] 分别是字符串A 、B的前i、j个字符构成的子串，我们得到一个子问题是“如何从字符串A[1…i] 修改到字符串B[1…j]”
1.插入一个字符，我们可以把这个当作是A[1…i] 、B[1…j-1]所用的操作次数op1，再加上插入一个b[j]，故总需要的操作次数是op1+1。
2.删除一个字符，我们可以把这个当作是A[1…i-1] 、B[1…j]所用的操作次数op2，再加上删除一个a[i]，故总需要的操作次数是op2+1。
3.替换一个字符，我们可以把这个当作是A[1…i-1] 、B[1…j-1]所用的操作次数op3，然后判断a[i]与b[j]是不是相等，如果相等，则总需要的操作次数是op3,反之，则需要进行替换这个操作，此时需要的总操作数就是op3+1。
综合上述，我们可以得到dp[i][j]=min(dp[i][j-1]+1,dp[i-1][j]+1,dp[i-1][j-1]+!(A[i]==B[j])),接下来就很简单了。

代码详解：

class Solution {
public:
    /*
     * @param word1: A string
     * @param word2: A string
     * @return: The minimum number of steps.
     */

    int minDistance(string &word1, string &word2) {
        // write your code here
        int n = word1.length();  
        int m = word2.length();  
        vector<vector<int> > dp(n+1,vector<int>(m+1,0));  
        for(int i = 1;i<=n;i++)  
            dp[i][0]=i;  
        for(int i=1;i<=m;i++)  
            dp[0][i]=i;  
        for(int i=1;i<=n;i++)  
        {  
            char c1 = word1[i-1];  
            for(int j=1;j<=m;j++)  
            {  
                char c2 = word2[j-1];  
                if(c1==c2)  
                    dp[i][j] = dp[i-1][j-1];  
                else  
                    dp[i][j] = min(dp[i-1][j],min(dp[i][j-1],dp[i-1][j-1]))+1;  

            }  
        }  
        return dp[n][m];  
    }

    void printvector(vector<vector<int>>res)
    {
        for(int i=0;i<res.size();i++)
        {
            for(int j=0;j<res[0].size();j++)
            {
                cout<<res[i][j]<<" ";
            }
            cout<<endl;
        }
    }
};

编辑距离II：
题目描述：
给你两个字符串 S 和 T, 判断他们是否只差一步编辑。

样例：
给你字符串 s = “aDb”, t= “adb”
返回 true

思路讲解：
首先对于这道题，我们先看一下这个编辑是什么意思，应该是指删除以及替换，这两个操作都是最多一次，这就导致，这两个字符串的长度最多相差1，故我们的分类点就是长度。
1.两个字符串长度相同时，只能进行的操作就是替换，所以我们只需要看需要替换的操作次数是多少，只要其大于1，就可以直接返回错误，如果只有一个，即他们相差一个编辑。
2.两个字符串长度相差1时，此时我们只能进行的操作是删除，所以我们利用双指针，分别指向两个字符串的起始处，然后判断其是否相等，如果相等则两个指针都移动下一个字符处，如果不等，我们可以将S的指针向后移动一下，一直这样循环下去，最后的判断标准就是t的指针是否移动到最后如果没有，说明他们不只差一步编辑，反之说明只差一步编辑。

详细代码：

class Solution {
public:
    /*
     * @param s: a string
     * @param t: a string
     * @return: true if they are both one edit distance apart or false
     */
    bool isOneEditDistance(string &s, string &t) {
        // write your code here
        int len1=s.length();
        int len2=t.length();

        if(len1==len2){
            int flag=0;//标记替换的次数
            for(int i=0;i<len1;i++)
            {
                if(flag==2){
                    return false;
                }else{
                    if(s[i]!=t[i]){
                        flag++;
                    }
                }
            }
            if(flag==1){
                return true;
            }else{
                return false;
            }
        }else if(abs(len1-len2)==1){
            if(len1>len2){
                int ps=0;//s的指针
                int pt=0;//t的指针
                while(ps<len1&&pt<len2){
                    if(s[ps]==t[pt]){
                        ps++;
                        pt++;
                    }else{
                        ps++;
                    }
                }
                if(pt==len2){
                    return true;
                }else{
                    return false;
                }
            }else{
                if(isOneEditDistance(t,s)){
                    return true;
                }else{
                    return false;
                }
            }
        }else{
            return false;
        }
    }
};