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

最小编辑距离的定义:编辑距离(Edit Distance),又称Levenshtein距离,是指两个字串之间,由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。

例如将kitten一字转成sitting

sittenks

sittinei

sitting(→g

俄罗斯科学家Vladimir Levenshtein1965年提出这个概念。

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

这个问题如何解决呢?

如果不经常做算法,那么看到这个问题会没有思路,因为把一个串儿编辑成另一个串方法应该是很多的,insertdeletesubstitute组合有很多种,那么如何度量最小编辑距离呢?

下面给出一种经典的算法思路:分而治之,把复杂的问题拆解成简单的子问题(并假设子问题的解已知)。这个思路最常见的一种建模方法就是数学中的数列,用前面的已知项推出未知项。在计算机中又叫递归或者递推。例如斐波拉契数列问题。

那么在此问题中,如何能得到最小编辑距离的递推公式呢?我们思考问题最好从最简单最特殊的地方出发。我们假设有两个字符串,情形有

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]就容易了。定义一个二维数组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=0;i--){
			for(int j=0;j

算法的时间复杂度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=0;i--){
			for(int j=0;j

算法的第一次改进:

原来的算法是创建一个大小为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

改进后的算法时间复杂度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 matchingALGORITHM

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

你可能感兴趣的:(Algorithm)