dp基础之难点解析K Edit Distance

重要的是先说三遍：先看Edit Distance，先看Edit Distance，先看Edit Distance！

本文是加强版K Edit Distance：给定N个字符串A，问哪些字符串和Target的最小编辑距离不大于K.
编辑操作和上面一样：增加（插入）、删、替换

例：
输入：A = [\"abc\",\"abd\",\"abcd\",\"adc,\"a\"](为了简单，只考虑小写字母的字符串)
Target = \"ac\"
K = 1
输出：[\"a\",\"abc\",\"adc\"]

问题分析:可以利用Edit Distance里，对每个字符串进行计算最小编辑距离，然后再把那些最小编辑距离不超过K的字符串输出来即可，但是这样会有很多冗余计算，时间会大大增加（相同前缀的字符串越多会该问题表现越明显）。比如，计算\"abc\"和\"abd\"时，两个字符穿都有相同前缀\"ab\"，dp解决该问题\"ab\"的最小编辑距离要重复计算两次，实际上，我们计算一次就好了。为此，我们加入前缀树（Trie）来优化计算。

转移方程：设f[Sp][j]表示前缀Sp和Target里前j个字符（Target[0,...,j-1]）的最小编辑距离，这里Sp表示A中字符串的前缀.。
下面p的父节点是q,Sq表示：Sq是Sp的少一个字符的前缀（例：Sp = \"abc\",则Sq = \"ab\"），情况和上面一致，
只不过把i用Sp代替，i-1用Sq代替。

f[Sp][j] = min{f[Sp][j-1]+1,        f[Sq][j-1]+1,             f[Sq][j]+1,f[Sq][j-1]|Sp[last] = Target[j-1]}
           min{case1：在Sp后插入Target[j-1];case2:用Target[j-1]替换Sp[last];case3:删除Sp[last]即变成Sq;case4:Sp[last]和Target最后一个相等}

初始条件：
空串和长度为L的最小编辑距离是L，空串就是root:f[Sroot][j] = f[\"\"][j] = j,(j = 0,...,n)
Sp和空串的最小编辑距离是Sp的长度:f[Sp][0] = len(Sp)

计算顺序：
    初始化f[Sroot][0]...f[Sroot][n]
    按照前缀树深度优先搜索计算每个f[Sp][0],...,f[Sp][n]

答案:f[Sp][n]<=K且Sp为给一个给定的单词的节点p的个数
    
时间复杂度：O(A中所有字符串的前缀个数*n),空间复杂度O(A中所有字符串的前缀个数*n)

代码及注释如下：

#前缀树节点结构
class TrieNode(object):
    def __init__(self):
        # 是否构成一个完成的单词，因为只有小写单词，所以把单词转到0-26之间
        self.is_word = False
        self.children = [None] * 26
        self.words = \"\"
#前缀树的类
class Trie(object):
    def __init__(self):
        self.root = TrieNode()

    def insert(self, s):
        \"\"\"insert a string called s from root.\"\"\"
        p = self.root
        n = len(s)
        for i in range(n):
            if p.children[ord(s[i]) - ord(\'a\')] is None:
                new_node = TrieNode()
                if i == n - 1: 
                    new_node.is_word = True
                    new_node.words = s
                p.children[ord(s[i]) - ord(\'a\')] = new_node
                p = new_node
            else:
                p = p.children[ord(s[i]) - ord(\'a\')]
                if i == n - 1:
                    p.is_word = True
                    p.words = s
                    return
                

class solution(object):
    def __init__(self,A,Target,K):
        self.target = Target
        self.k = K
        self.n = len(Target)
        self.res = []
        
        #init Tire
        self.trie = Trie()
        for i in range(len(A)):
            self.trie.insert(A[i])
            
        #init f[\"\"][0,...,n] 
        self.f = [i for i in range(self.n+1)]
        
    #dfs函数:在节点p,前缀Sp,f[j]:f[Sp][j]即前缀Sp转换成Target的前j个字符的最小编辑距离。
    #todo:Sp+\"a\",...,Sp+\"z\",will update :f-->nf，
    def dfs(self, p,f):
        nf  = [0 for i in range(self.n+1)]
        
        #从root节点开始看是否有A中字符串
        if p.is_word:
            #这个字符串的最小编辑距离不大于K,加入结果res里
            if f[self.n]<=self.k:
                self.res.append(p.words)
                
        #继续向下找p的子节点
        #next prefix\'s char is i in A
        for i in range(26):
            #儿子节点为空，跳过
            if p.children[i] == None:
                continue
            #特殊处理nf[0]
            #f[Sq][0] = 0
            #现在Sq-->Sp,也就是f[Sq][0]-->f[Sp][0]，前缀多了一个字符,变成Target[0]
            #因为f[Sp][0] = len(Sp),现在Sp多了一个字符，只要在原来的f[0]基础上加1就可以。
            nf[0] = f[0]+1
            
            #next Target\'s char is self.target[j-1]
            for j in range(1,self.n+1):
                #case1,2,3###i:Sp-->nf  i-1:Sq-->f
                #f[Sp][j] = min{f[Sp][j-1]+1,        f[Sq][j-1]+1,             f[Sq][j]+1}
                nf[j] = min(nf[j-1]+1,f[j-1]+1,f[j]+1)
                
                #case4
                #f[Sp][j] = min{f[Sp][j],f[Sq][j-1]|Sp[last] = Target[j-1]}
                #把字符转成0-26之间
                c = ord(self.target[j-1])-ord(\"a\")
                if i == c:
                    nf[j] = min(nf[j],f[j-1])
            #寻找子节点
            self.dfs(p.children[i],nf)
        return self.res       
    #也就是从root节点开始深度遍历前缀树，并且更新每一轮的f值，将编辑距离小于K的字符串加到res里，最后返回res
   
    #dfs返回result
    def return_res(self):
        return self.dfs(self.trie.root,self.f)

A = [\"abc\",\"abd\",\"abcd\",\"adc\",\"a\"]
Target = \"ac\"
K = 1
C = solution(A,Target,K)
C.return_res()
#输出:[\'a\', \'abc\', \'adc\']

说明：可以把递归里的f直接放在TrieNode的结构里，就不用带着f在函数里递归了