字符串编辑距离与动态规划

blog

算法非原创，只是整理，并尝试说的更完整和易理解。

字符串编辑距离是什么

将一个字符串转换成另一个字符串时需要付出的代价。转换可以采用插入、删除、替换三种编辑方式。比如说把字符串“post”转换成“get”，直观看来它们的编辑距离颇大，并有许多种转换方式。第一种[替换p为g，替换o为e，删除
s]这样它们的转换代价为3。第二种[删除p，删除o，删除s，删除g，删除e]这样它们的转换代价为5。不同的转换方式需要的编辑次数不一样，最少的那个编辑方式所需的次数就是这量字符串的编辑距离。

简单的递归算法

咋一看这个问题似乎挺难，因为对同一个字符串需要选择在不同位置上采用不同的动作才能完成任务，可能会有一种无法下手的感觉。但是用计算机的思维方式来看，我们可以把一个复杂的大问题转换成一系列简单的小问题，有多
简单呢？比如要把“post”转换成“get”,我们可以先考虑如何用最小的代价把“post”转换成“et”,或者是把“ost”转换成“get”z或者是把“ost”转换成“et”，总之是尝试用三种办法（插入、删除、替换）使问题的复杂度降级，也就是用> 一种递归的方式去处理.因为对每一步转换可选择三种不同的方式(插入、删除、替换)，所以需要对比每一部的最优方式。为了调试简单所以就用js做示例。

function editDis(str1,str2){
    if(str1.length==0||str2.length==0){
       return Math.abs(str1.length-str2.length)
    }
    if(str1.charAt(0)===str2.charAt(0)){
       return editDis(str1.substr(1,str1.length),str2.substr(1,str2.length))
    }
    var edInsert = editDis(str1,str2.substr(1,str2.length))+1;
    var edDelete = editDis(str1.substr(1,str1.substr.length),str2)+1;
    var edReplace = editDis(str1.substr(1,str1.substr.length),str2.substr(1,str2.length))+1;
    return Math.min(edInsert,edDelete,edReplace);
}

运行结果如下

editDis("post","get")
3

优化的递归算法

可以看到上边的简单算法就可以得出正确的结果了，虽然简单却造成了大量的计算浪费，时间复杂度太高，在很多子串上做了重复计算。优化？最先想到的是什么？做缓存啊，把计算过的结果存在表里下次计算首先查表就可以了。
照我的习惯就直接弄一个map做缓存了，但本文的主题不还有动态规划么，所以考虑用动态规划的思想去解决。动态规划算法通常基于一个递推公式及一个或多个初始状态，当前问题的解由上一子问题的解推出。对我们的问题来说> ，递归仍然是最容易的办法，只不过可以把每一步子问题的解也就是状态存表供可能存在的其它子问题使用，其实对这个问题来说还是缓存啦。。

var editStatusArr = Array(Array())
function editDisWithStatus(str1,str2,x,y){
  if(x==0&&y==0){
      for(i=0;i<=str1.length;i++)
          editStatusArr[i]=Array();
   }
   if(editStatusArr[x]!=undefined&&editStatusArr[x][y]!=undefined){
       console.log(x+"_"+y);
       return editStatusArr[x][y];
   } else {
       var dis = 0;
       if((str1.length)==0){
           dis = str2.length;
       } else if((str2.length)==0){
           dis = str1.length;
       } else {
           if(str1.charAt(0)===str2.charAt(0)){
           dis = editDisWithStatus(str1.substr(1,str1.length),str2.substr(1,str2.length),x+1,y+1);
           } else {
              var edInsert = editDisWithStatus(str1,str2.substr(1,str2.length),x,y+1)+1;
               var edDelete = editDisWithStatus(str1.substr(1,str1.substr.length),str2,x+1,y)+1;
               var edReplace = editDisWithStatus(str1.substr(1,str1.substr.length),str2.substr(1,str2.length),x+1,y+1)+1;
               dis = Math.min(edInsert,edDelete,edReplace);
           }
       }
       editStatusArr[x][y]= dis;
       console.log("x:"+x+" y:"+y+" dis:"+dis);
       return dis;
  }
}

运行结果如下

  editDisWithStatus("post","get",0,0)
  3

递推算法

有了上面递归的实现，我们基本上可以确定递推关系了．呐，就是下面这个样子，首先把其中一个字串的字符拆开排好，然后在下面标上１２３４，１前面画０，然后在纵向上在１下面画１２３，左侧表上另一个字串的字符．这样
递推关系的初始态就有了，接下来就是填其它的数字了，要确定一个空位的数字首先看该空位对应的两个字符是否一样，如果一样的话就取该空位左，左上，上，三个方向上的最小值，如果不一样就取三个方向上的最小值加１．嗯
？你不要骗我！这和递归的实现根本不相似．递归是从最复杂的一步开始思考，由繁至简．而递推是从初始态开始的，由简至繁．其实是差不多的．

		p	o	s	t
	0	1	2	3	4
g	1	1	2	3	4
e	2	2	2	3	4
t	3	3	3	3	3

function editDis(str1,str2){
  var editStatusArr = Array(Array())
    var i=0,j=0;
    for(i=0;i<=str1.length;i++){
        editStatusArr[i]=Array();
    }
    for(j=0;j<=str2.length;j++){
        editStatusArr[0][j]=j;
    }
    for(i=0;i<=str1.length;i++){
        editStatusArr[i][0]=i;
    }

    for(i=1;i<=str1.length;i++){
        for(j=1;j<=str2.length;j++){
            if(str1.charAt(i-1)===str2.charAt(j-1)){
               editStatusArr[i][j]=editStatusArr[i-1][j-1];
           } else {
               editStatusArr[i][j]=Math.min(editStatusArr[i][j-1],editStatusArr[i-1][j],editStatusArr[i-1][j-1])+1;
           }
       }
 }
 return editStatusArr[i-1][j-1];
}