Minimum edit distance（levenshtein distance）(最小编辑距离)初探

最小编辑距离的定义：编辑距离（Edit Distance），又称Levenshtein距离。是指两个字串之间，由一个转成还有一个所需的最少编辑操作次数。许可的编辑操作包含将一个字符替换成还有一个字符。插入一个字符，删除一个字符。

比如将kitten一字转成sitting：

sitten（k→s）

sittin（e→i）

sitting（→g）

俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念。

Thewords `computer' and `commuter' are very similar, and a change of just oneletter, p->m will change the first word into the second. The word `sport'can be changed into `sort' by the
deletion of the `p', or equivalently, `sort'can be changed into `sport' by the insertion of `p'.

Theedit distance of two strings, s1 and s2, is defined as the minimum number ofpoint mutations required to change s1 into s2, where a point mutation is oneof:

1.   change a letter,

2.   insert a letter, or

3.   delete a letter

这个问题怎样解决呢？

假设不常常做算法。那么看到这个问题会没有思路。由于把一个串儿编辑成还有一个串方法应该是非常多的，insert，delete。substitute组合有非常多种，那么怎样度量最小编辑距离呢？

以下给出一种经典的算法思路：分而治之。把复杂的问题拆解成简单的子问题（并如果子问题的解已知）。这个思路最常见的一种建模方法就是数学中的数列，用前面的已知项推出未知项。在计算机中又叫递归或者递推。

比如斐波拉契数列问题。

那么在此问题中，怎样能得到最小编辑距离的递推公式呢？我们思考问题最好从最简单最特殊的地方出发。

我们如果有两个字符串，情形有

1.两个都是空串          d('', '') = 0   -- ''= empty string

2.有一个是空串          d(s, '')  = d('', s)= |s|  -- i.e. length of s（连续删除或插入）

3.两个非空串            d(s1+ch1,s2+ch2)

此时，d(s1+ch1, s2+ch2)的结果得来无非是三种情况决定。第一种如果d(s1,s2)已知，我们把两个串的最后一个字符做替换操作。则d(s1+ch1,
s2+ch2)= d(s1, s2) + if ch1=ch2 then 0 else 1。另外一种可能是如果d(s1,s2+ch2)已知。把第一个串的ch1删除，则d(s1+ch1,
s2+ch2)= d(s1,s2+ch2)+1；第三中可能是如果d(s1+ch1,s2)已知，在第一个串末尾插入ch2。则d(s1+ch1,
s2+ch2)= d(s1+ch1,s2)+1。那么究竟是哪一种情况得到了d(s1+ch1,s2+ch2)肯定是最小的那个决定，因此

d(s1+ch1,s2+ch2) =min[ d(s1, s2) + if ch1=ch2 then 0 else 1 ,d(s1+ch1, s2) + 1,d(s1,s2+ch2) + 1 ]

接下来我们量化定义d[i,j]是一个长度为i的串s和一个长度为j的串t的最小编辑距离。

那么

d[0,0]=0

d[0,j]=j;(前者插入j个字母或后者删除j个字母)

d[i,0]=i;(前者删除i个字母或后者插入i个字母)

d[i,j]=min{d[i-1,j-1]+(s[i]==t[j]?0:1), d[i-1,j]+1, d[i,j-1]+1 }

得到递推式后，求d[i,j]就easy了。定义一个二维数组distance[][]来存储最小编辑距离，以下试java代码：

package Algorithms;

public class EditDistanceComputer {
	private int sWeight = 1;		//替换操作substitute的权值，也就是代价overhead
	private int iWeight = 1;		//插入操作insert的权值
	private int dWeight = 1;		//删除操作delete的权值
	public static void main(String[] args){
		String s = "intention";
		String t = "execution";
		EditDistanceComputer editDC = new EditDistanceComputer();
		System.out.println(editDC.getMinEditDistance(s, t));
	}

	public void setWeight(int sWeight, int iWeight, int dWeight){
		this.sWeight = sWeight;
		this.iWeight = iWeight;
		this.dWeight = dWeight;
	}

	public int getMinEditDistance(String s, String t){
		int m = s.length();
		int n = t.length();
		//申请(m+1)*(n+1)矩阵空间
		int[][] distance = new int[m+1][n+1];
		//初始化特殊值
		for(int i=0;i<m+1;i++){
			distance[i][0] = i;
		}
		for(int i=0;i<n+1;i++){
			distance[0][i] = i;
		}
		//利用递推公式遍历填充整个距离矩阵
		for(int i=1;i<=m;i++){
			for(int j=1;j<=n;j++){
				distance[i][j] = getMin(distance[i-1][j]+dWeight, distance[i][j-1]+iWeight, distance[i-1][j-1]+(s.charAt(i-1)==t.charAt(j-1)?0:sWeight));
			}
		}

		printMatrix(distance,m+1,n+1);

		return distance[m][n];
	}
	//打印矩阵
	public void printMatrix(int[][] matrix, int rownum, int colnum){
		for(int i=rownum-1;i>=0;i--){
			for(int j=0;j<colnum;j++){
				System.out.print(matrix[i][j]+"	");
			}
			System.out.println();
		}
	}

	private int getMin(int a, int b, int c){
		return (a<b)?(a<c?

a:c):(b<c?b:c);
	}
}

算法的时间复杂度O(m*n),空间复杂度O(m*n)。

我们已经计算除了最小编辑距离，那么怎样把s经过distance[i][j]次操作转换为t呢？看看前面的矩阵，我们得出distance[i][j]实际上有一条路径。假设记下这条路径，那么我们就行回溯，找到相应的操作。接下来我们定义记录每一次操作的回溯矩阵backtrace[][]

package Algorithms;
enum TraceOperator {L,D,S}; //L:LEFT D:DOWN S:SLANT
public class EditAlignment {
	private int sWeight = 1;		//替换操作substitute的权值，也就是代价overhead
	private int iWeight = 1;		//插入操作insert的权值
	private int dWeight = 1;		//删除操作delete的权值
	private int m = 0;
	private int n = 0;
	int[][] distance = null;
	TraceOperator[][] backtrace = null;
	StringBuffer sb = null;
	public static void main(String[] args){
		String s = "intention";
		String t = "execution";
		EditAlignment editDC = new EditAlignment();
		System.out.println(editDC.getMinEditDistance(s, t));
		editDC.Alignment(s, t);
	}

	public void setWeight(int sWeight, int iWeight, int dWeight){
		this.sWeight = sWeight;
		this.iWeight = iWeight;
		this.dWeight = dWeight;
	}

	public void Alignment(final String s, final String t){
		sb = new StringBuffer(s);
		System.out.println("SourceString StringBuffer before Alignment: " + sb);
		if(backtrace == null || distance == null) System.exit(-1);
		int i = m;
		int j = n;
		while(backtrace[i][j] != null){
			switch(backtrace[i][j]){
				case S:
					if(s.charAt(i-1)!=t.charAt(j-1)){
						sb.replace(i-1, i, ""+t.charAt(j-1));
						System.out.println("source string: " + sb);
						System.out.println("target string: " + t);
						System.out.println("---------------------------------------");
					}
					i--;j--;
					break;
				case L:
					sb.insert(i, t.charAt(j-1));
					j--;
					System.out.println("source string: " + sb);
					System.out.println("target string: " + t);
					System.out.println("---------------------------------------");
					break;
				case D:
					sb.deleteCharAt(i-1);
					i--;
					System.out.println("source string: " + sb);
					System.out.println("target string: " + t);
					System.out.println("---------------------------------------");
					break;
				default:
					System.exit(-1);
			}
		}
		System.out.println("SourceString StringBuffer after Alignment: " + sb);
	}

	public int getMinEditDistance(final String s, final String t){
		m = s.length();                     //看成二维矩阵的话，m相应行，也就是纵坐标。n相应列。也就是横坐标
		n = t.length();
		int a,b,c;
		distance = new int[m+1][n+1];
		backtrace = new TraceOperator[m+1][n+1];
		initMatrix(m+1, n+1);
		for(int i=1;i<=m;i++){
			for(int j=1;j<=n;j++){
				a = distance[i-1][j]+dWeight;	//deletion对于s的操作，下面都是以s为源串
				b = distance[i][j-1]+iWeight;	//insertion
				c = distance[i-1][j-1]+(s.charAt(i-1)==t.charAt(j-1)?0:sWeight);//substitution
				if(a == getMin(a,b,c)){
					distance[i][j] = a;
					backtrace[i][j]=TraceOperator.D;//deletion
				}
				else if(b == getMin(a,b,c)){
					distance[i][j] = b;
					backtrace[i][j]=TraceOperator.L;//insertiodn
				}
				else if(c == getMin(a,b,c)){
					distance[i][j] = c;
					backtrace[i][j]=TraceOperator.S;//substitution
				}
			}
		}

		printMatrix(distance,m+1,n+1);
		System.out.println();
		printMatrix(backtrace,m+1,n+1);

		return distance[m][n];
	}

	public void printMatrix(int[][] matrix, int rownum, int colnum){
		for(int i=rownum-1;i>=0;i--){
			for(int j=0;j<colnum;j++){
				System.out.print(matrix[i][j]+"	");
			}
			System.out.println();
		}
	}

	public void printMatrix(TraceOperator[][] matrix, int rownum, int colnum){
		for(int i=rownum-1;i>=0;i--){
			for(int j=0;j<colnum;j++){
				System.out.print(matrix[i][j]+"	");
			}
			System.out.println();
		}
	}

	private void initMatrix(int x, int y){
		for(int i=0;i<x;i++){
			distance[i][0] = i;
		}
		for(int i=0;i<y;i++){
			distance[0][i] = i;
		}

		for(int i=1;i<x;i++){
			backtrace[i][0] = TraceOperator.D ;
		}
		for(int i=1;i<y;i++){
			backtrace[0][i] = TraceOperator.L;
		}
	}

	private int getMin(int a, int b, int c){
		return (a<b)?

(a<c?a:c):(b<c?b:c);
	}
}

算法的第一次改进：

原来的算法是创建一个大小为s*t的矩阵。假设全部字符串加起来是1000个字符那么长的话，那么这个矩阵就会是1M。假设字符串是10000个字符，那么矩阵就是100M。假设元素都是整数（这里是指数字。Int32）的话。那么矩阵就会是4*100M
== 400MB这么大。

如今的算法版本号仅仅使用2*t个元素，这使得后面给出的样例成为2*10,000*4 = 80 KB。其结果是。不但内存占用更少，并且速度也变快了。由于这使得内存分配仅仅须要非常少的时间来完毕。当两个字符串的长度都是1k左右时，新算法的效率是旧算法的两倍！

来看看改进的算法吧，对于计算编辑距离，假设我们不须要回溯，而是仅仅想知道两者的相似度，那么上面的算法存储空间就是能够改进的，细致观察你会发现递推公式d[i,j]=min{ d[i-1,j-1]+(s[i]==t[j]?0:1), d[i-1,j]+1, d[i,j-1]+1}的计算过程以及距离矩阵。你会发现当前距离的计算仅仅和前一行以及当前行有关，即每次计算都仅仅须要斜向的[i-1,j-1]、横向的[i,j-1]和纵向的[i-1,j]。而我们如今不须要知道中间结果，仅仅须要终于结果。那么能够仅仅要两行存储空间，进行迭代计算就可以。如今仅仅须要cur_row[]和pre_row[]两个向量空间就可以。

以下是改进的代码：

package Algorithms;

public class EditDistanceComputer1 {
	private int sWeight = 1;		//替换操作substitute的权值，也就是代价overhead
	private int iWeight = 1;		//插入操作insert的权值
	private int dWeight = 1;		//删除操作delete的权值
	public static void main(String[] args){
		String s = "GUMBO";
		String t = "GAMBOL";
		EditDistanceComputer1 editDC = new EditDistanceComputer1();
		System.out.println(editDC.getMinEditDistance(s, t));
	}

	public void setWeight(int sWeight, int iWeight, int dWeight){
		this.sWeight = sWeight;
		this.iWeight = iWeight;
		this.dWeight = dWeight;
	}

	public int getMinEditDistance(String s, String t){
		int m = s.length();
		int n = t.length();
		int[] cur_row = new int[n+1];
		int[] pre_row = new int[n+1];
		int[] temp = null;
		for(int i=0;i<n+1;i++){
			pre_row[i] = i;
		}

		for(int i=1;i<=m;i++){
			cur_row[0] = i;
			for(int j=1;j<=n;j++){
				cur_row[j] = getMin(pre_row[j]+dWeight, cur_row[j-1]+iWeight, pre_row[j-1]+(s.charAt(i-1)==t.charAt(j-1)?0:sWeight));
			}

			printVector(cur_row,n+1);
			printVector(pre_row,n+1);
			System.out.println();
			//交换当前行和先前行，为进行下一轮迭代做准备，腾出pre_row的位置
			temp = cur_row;
			cur_row = pre_row;
			pre_row = temp;
		}

		return pre_row[n];
	}

	public void printVector(int[] vector,int colnum){

			for(int j=0;j<colnum;j++){
				System.out.print(vector[j]+"	");
			}
			System.out.println();
	}

	private int getMin(int a, int b, int c){
		return (a<b)?

(a<c?

a:c):(b<c?

b:c);
	}
}

改进后的算法时间复杂度O(m*n),空间复杂度O(2*n)

下图是对上述计算过程的解释：

最后，这个算法的时间复杂度还是O(m*n),空间复杂度O(2*n)，事实上还有其它算法，在某些应用场景更加高效。眼下先写到这儿。当前最高效的算法是某个公司的商业机密。只是，关于最小编辑距离应用很广泛，小到我们平时使用的IDE的代码自己主动补全，代码提示，搜索引擎关键词提示等等，大到远程屏幕更新。压缩传输字符串，以及机器识别中的距离度量等。都有这方面的原理。

參考：

Minimum edit distance

http://web.stanford.edu/class/cs124/lec/med.pdf

Dynamic ProgrammingAlgorithm (DPA) for Edit-Distance

http://www.allisons.org/ll/AlgDS/Dynamic/Edit/

AN EXTENSION OF UKKONEN'SENHANCED DYNAMIC PROGRAMMING ASM
（Approximate string matching）ALGORITHM

http://www.berghel.net/publications/asm/asm.php

Fast Approximate String Matching in a Dictionary

http://citeseer.ist.psu.edu/viewdoc/download?doi=10.1.1.21.3317&rep=rep1&type=pdf