最小编辑距离

编辑距离
       关于两个字符串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实现的代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int Min(int a,int b,int c)
{
    int min=a;
    if(b<min)
        min=b;
    if(c<min)
        min=c;
    return min;
}

int ComputeDistance(char s[],char t[])
{
 int n=strlen(s);
 int m=strlen(t);
 int i;
 //没有用二维数组的原因
 //int d[][]=new int[n+1,m+1];
 int **d=(int **)malloc((n+1)*sizeof(int *));
 for( i=0;i<=n;i++)
 {
     d[i]=(int *)malloc((m+1)*sizeof(int));
 }

 if(n==0)
     return m;
 if(m==0)
     return n;
 for( i=0;i<=n;i++)
     d[i][0]=i;
 for(int j=0;j<=m;j++)
     d[0][j]=j;
 for( i=1;i<=n;i++)
 {
     for(int j=1;j<=m;j++)
     {
         if(t[j-1]==s[i-1])
             d[i][j]=d[i-1][j-1];
         else
             d[i][j]=Min(d[i-1][j],d[i][j-1],d[i-1][j-1])+1;         
     }
 }
 return d[m][n];
}

int main()
{
    char a[100];
    char b[100];
    printf("请输入字符串1\n");
    scanf("%s",&a);
    printf("请输入字符串2\n");
    scanf("%s",&b);

    int result=ComputeDistance(a,b);
    printf("%d\n",result);
    return 0;
}

用C#实现的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SubLong
{
    class Program
    {
        static int[,] martix;
      
        static string str1 = string.Empty;
        static string str2 = string.Empty;

        static void Main(string[] args)
        {
            while (true)
            {
                str1 = Console.ReadLine();
                str2 = Console.ReadLine();
                martix = new int[str1.Length + 1, str2.Length + 1];//数组的长度动态分配
                Console.WriteLine("字符串{0}和{1}的编辑距离为：{2}",str1,str2,LD());
            }
        }
        static int LD()
        {
            //初始化边界，过滤掉0的情况，现在明白初始化的原因了吧
            for (int i = 0; i<= str1.Length; i++)
                martix[i, 0] = i;

            for (int j = 0; j <= str2.Length; j++)
                martix[0, j] = j;

            //填充矩阵
            for (int i = 1; i <= str1.Length; i++)
            {
                for (int j = 1; j <= str2.Length; j++)
                {
                    if (str1[i - 1] == str2[j - 1])
                    {
                        martix[i, j] = martix[i - 1, j - 1];
                    }
                    else
                    {
                        var temp1 = Math.Min(martix[i - 1, j], martix[i, j - 1]);
                        var min = Math.Min(temp1, martix[i - 1, j - 1]);
                        martix[i,j]=min+1;
                    }
                }
            }
            return martix[str1.Length,str2.Length];
        }//LD
    }
}