最小编辑距离

编辑距离
       关于两个字符串s1,s2的差别，可以通过计算他们的最小编辑距离来决定。
       所谓的编辑距离:  让s1和s2变成相同字符串需要下面操作的最小次数。
1.         把某个字符ch1变成ch2
2.         删除某个字符
3.         插入某个字符
例如      s1 = “12433” 和s2=”1233”;
                     则可以通过在s2中间插入4得到12433与s1一致。
                    即 d(s1,s2) = 1 (进行了一次插入操作)
编辑距离的性质
计算两个字符串s1+ch1, s2+ch2的编辑距离有这样的性质:
1.         d(s1,””) = d(“”,s1) = |s1|    d(“ch1”,”ch2”) = （ch1 == ch2） ? 0 : 1;
2.         d(s1+ch1,s2+ch2) = min(d(s1,s2)+（ch1==ch2 ）? 0 : 1 ,d(s1+ch1,s2),d(s1,s2+ch2)  );
 复杂度分析
从上面性质2可以看出计算过程呈现这样的一种结构(假设各个层用当前计算的串长度标记，并假设两个串长度都为 n )
可以看到，该问题的复杂度为指数级别 3 的 n 次方，对于较长的串，时间上是无法让人忍受的。
 分析:     在上面的结构中，我们发现多次出现了 (n-1,n-1), (n-1,n-2)……。换句话说该结构具有重叠子问题。再加上前面性质2所具有的最优子结构。符合动态规划算法基本要素。因此可以使用动态规划算法把复杂度降低到多项式级别。
动态规划求解
       首先为了避免重复计算子问题，添加两个辅助数组。
一.     保存子问题结果。
M[ |s1| ,|s2| ] , 其中M[ i , j ] 表示子串 s1(0->i) 与 s2(0->j) 的编辑距离
二.     保存字符之间的编辑距离.
E[ |s1|, |s2| ] , 其中 E[ i, j ] =(s[i]== s[j])? 0 : 1
三.   新的计算表达式
根据性质1得到
M[ 0,0] = 0;
M[ s1i, 0 ] = |s1i|;
M[ 0, s2j ] = |s2j|;
根据性质2得到
M[ i, j ]   = min(     m[i-1,j-1] + E[ i, j ] ,
                            m[i, j-1] ,
                            m[i-1, j]  );
       复杂度
              从新的计算式看出，计算过程为
              i=1 -> |s1|
                     j=1 -> |s2|
                            M[i][j] = ……
              因此复杂度为 O( |s1| * |s2| ) ，如果假设他们的长度都为n，则复杂度为 O(n^2)

用C实现的代码：

 1 #include<stdio.h>

 2 #include<stdlib.h>

 3 #include<string.h>

 4 

 5 int Min(int a,int b,int c)

 6 {

 7     int min=a;

 8     if(b<min)

 9         min=b;

10     if(c<min)

11         min=c;

12     return min;

13 }

14 

15 int ComputeDistance(char s[],char t[])

16 {

17  int n=strlen(s);

18  int m=strlen(t);

19  int i;

20  //没有用二维数组的原因

21  //int d[][]=new int[n+1,m+1];

22  int **d=(int **)malloc((n+1)*sizeof(int *));

23  for( i=0;i<=n;i++)

24  {

25      d[i]=(int *)malloc((m+1)*sizeof(int));

26  }

27 

28  if(n==0)

29      return m;

30  if(m==0)

31      return n;

32  for( i=0;i<=n;i++)

33      d[i][0]=i;

34  for(int j=0;j<=m;j++)

35      d[0][j]=j;

36  for( i=1;i<=n;i++)

37  {

38      for(int j=1;j<=m;j++)

39      {

40          if(t[j-1]==s[i-1])

41              d[i][j]=d[i-1][j-1];

42          else

43              d[i][j]=Min(d[i-1][j],d[i][j-1],d[i-1][j-1])+1;         

44      }

45  }

46  return d[m][n];

47 }

48 

49 int main()

50 {

51     char a[100];

52     char b[100];

53     printf("请输入字符串1\n");

54     scanf("%s",&a);

55     printf("请输入字符串2\n");

56     scanf("%s",&b);

57 

58     int result=ComputeDistance(a,b);

59     printf("%d\n",result);

60     return 0;

61 }

View Code

用C#实现的代码：

 1 using System;

 2 using System.Collections.Generic;

 3 using System.Linq;

 4 using System.Text;

 5 

 6 namespace SubLong

 7 {

 8     class Program

 9     {

10         static int[,] martix;

11       

12         static string str1 = string.Empty;

13         static string str2 = string.Empty;

14 

15         static void Main(string[] args)

16         {

17             while (true)

18             {

19                 str1 = Console.ReadLine();

20                 str2 = Console.ReadLine();

21                 martix = new int[str1.Length + 1, str2.Length + 1];//数组的长度动态分配

22                 Console.WriteLine("字符串{0}和{1}的编辑距离为：{2}",str1,str2,LD());

23             }

24         }

25         static int LD()

26         {

27             //初始化边界，过滤掉0的情况，现在明白初始化的原因了吧

28             for (int i = 0; i<= str1.Length; i++)

29                 martix[i, 0] = i;

30 

31             for (int j = 0; j <= str2.Length; j++)

32                 martix[0, j] = j;

33 

34             //填充矩阵

35             for (int i = 1; i <= str1.Length; i++)

36             {

37                 for (int j = 1; j <= str2.Length; j++)

38                 {

39                     if (str1[i - 1] == str2[j - 1])

40                     {

41                         martix[i, j] = martix[i - 1, j - 1];

42                     }

43                     else

44                     {

45                         var temp1 = Math.Min(martix[i - 1, j], martix[i, j - 1]);

46                         var min = Math.Min(temp1, martix[i - 1, j - 1]);

47                         martix[i,j]=min+1;

48                     }

49                 }

50             }

51             return martix[str1.Length,str2.Length];

52         }//LD

53     }

54 }

View Code