LintCode: Edit Distance

dp注意问题

　　递推式

　　初值

　　空间优化

1. bfs

题目里有“最小”字样，符合bfs关键词：上界len(S)+len(T)

实际上不可行；

2. dp

删除字符很麻烦

换个角度，变为字符串“对齐问题”：

S = ABCF

T = DBFG

S：A B C F -

T：D B - F G

对应位置相同则不扣分，不同则扣一分（需要修改一次）

两个特殊字符“-”不会对应

S位置“-”代表增字符

T位置“-”代表删字符

使扣分最少

dp[i][j]表示S的前i个位置和T的前j个位置对齐的最少得分

dp[i][j] = min(dp[i-1][j-1]+same(i,j), dp[i-1][j]+1, dp[i][j-1]+1)

　　dp[i-1][j-1]+same(i,j)对应S第i个字符和T的第j个字符对齐

　　dp[i-1][j]+1对应S第i个字符和“-”对齐，即删掉S中第i个字符

　　dp[i][j-1]+1对应T第j个字符和“-”对齐，即在S中加入该字符

初值

　　dp[0][j] = j, j>=0

　　dp[i][0] = i, i>=0

时间复杂度：O(len(S)*len(T))

空间优化：省掉一维

　　对每个i，正向循环j　

　　　　注意保存dp[i-1][j-1]，因为j-1已经是新值

class Solution {
public:    
    /**
     * @param word1 & word2: Two string.
     * @return: The minimum number of steps.
     */
    int minDistance(string word1, string word2) {
        // write your code here
        int m = word1.length(), n = word2.length();
        vector<vector<int> > dp(m + 1, vector<int>(n + 1));
        for (int i = 0; i <= m; ++i) {
            for (int j = 0; j <= n; ++j) {
                if ( i== 0 ) {
                    dp[i][j] = j;
                } else if (j == 0) {
                    dp[i][j] = i;
                } else {
                    dp[i][j] = min(dp[i - 1][j - 1] + ((word1[i - 1] == word2[j - 1])?0:1),
                                   min(dp[i][j - 1] + 1, dp[i - 1][j] + 1)
                                );
                }
            }
        }
        return dp[m][n];
    }
};

空间优化

class Solution {
public:    
    /**
     * @param word1 & word2: Two string.
     * @return: The minimum number of steps.
     */
    int minDistance(string word1, string word2) {
        // write your code here
        int m = word1.length(), n = word2.length();
        // vector<vector<int> > dp(m + 1, vector<int>(n + 1));
        vector<int> dp(n + 1);
        for (int i = 0; i <= m; ++i) {
            int last;
            for (int j = 0; j <= n; ++j) {
                if ( i== 0 ) {
                    dp[j] = j;
                } else if (j == 0) {
                    last = dp[j];
                    dp[j] = i;
                } else {
                    int tmp = dp[j];
                    dp[j] = min(last + ((word1[i - 1] == word2[j - 1])?0:1),
                                   min(dp[j - 1] + 1, dp[j] + 1)
                                );
                    last = tmp;
                }
            }
        }
        return dp[n];
    }
};