字符串相似度算法和最大公共子串提取算法

最新推荐文章于 2023-10-31 17:07:15 发布

转载最新推荐文章于 2023-10-31 17:07:15 发布 · 1.5k 阅读

文章标签：

#算法

数据结构&算法专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍了字符串匹配算法中的编辑距离与最长公共子串的概念及其实现方式，通过具体实例展示了如何计算字符串之间的相异性，并提供C++代码实现。此外，还阐述了提取最长公共子串的方法及其应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

字符串相似度算法和最大公共子串提取算法

1. Levenshtein Distance

该算法又称之为 "编辑距离"，用于计算两个字符串的相似程度。原理很简单，就是返回两个字串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。次数越少，意味着字符串相似度越高。

例如将 kitten 转换成 sitting：

sitten （k→s）

sittin （e→i）

sitting （→g）

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

算法原理：

下面为你展示一个编辑距离计算的实例。源字符串是 "GUMBO" ，目标字符串是 "GAMBOL".

Steps 1 and 2

Steps 3 to 6 When i = 1

Steps 3 to 6 When i = 2

Steps 3 to 6 When i = 3

Steps 3 to 6 When i = 4

Steps 3 to 6 When i = 5

Step 7

编辑距离就是矩阵右下角的数字 2. 这与我们的实际计算相符. "GUMBO" 能够转换到 "GAMBOL" 通过将 "U" 替换为 "A" 和插入 "L" (1次替换 + 1次插入 = 2次改变).

C++ 算法实现Code：

//相似程度分析函数（运用“编辑距离Levenshtein Distance”算法）
//返回将第一个字符串转换(删除、插入、替换)成第二个字符串的最少编辑次数
int Levenshtein_Distance(const string strL1,const string strL2)
{
    //获得两字符串长度
    int L1=strL1.size(),L2=strL2.size();
    //构建处理二维矩阵
    vector<vector<int>> x(L2+1,L1+1);
    //特殊情况返回
    if(strL1==strL2)
    {
        return 0;
    }
    else
    {
        if(L1==0)
        {
            return L2;
        }
        if(L2==0)
        {
            return L1;
        }
    }
    //依次为第一行和第一列赋值
    for(int i=1;i<=L1;i++)
    {
        x[0][i]=i;
    }
    for(int i=1;i<=L2;i++)
    {
        x[i][0]=i;
    }
  
    for(int j=1;j<=L1;j++)
    {
        for(int i=1;i<=L2;i++)
        {
            int cost;
            //由矩阵对应字符串字符获得代价值cost
            if(strL1[j-1]==strL2[i-1])
            {
                cost=0;
            }
            else
            {
                cost=1;
            }
            //由2*2矩阵周围数字确定当前位置数值（求最小值）
            x[i][j]=min(x[i-1][j-1]+cost,x[i-1][j]+1,x[i][j-1]+1);
        }
    }
  
    return x[L2][L1];
}
  
//求最小值函数
int min(const int N1,const int N2,const int N3)
{
    int min;
    if(N1<N2)
    {
        if(N1<N3)
        {
            return N1;
        }
        else
        {
            return N3;
        }
    }
    else
    {
        if(N2<N3)
        {
            return N2;
        }
        else
        {
            return N3;
        }
    }
}

2. LCS

LCS (Longest Common Subsequence) 算法用于找出两个字符串最长公共子串。

算法原理：

(1) 将两个字符串分别以行和列组成矩阵。

(2) 计算每个节点行列字符是否相同，如相同则为 1。

(3) 通过找出值为 1 的最长对角线即可得到最长公共子串。

人民共和时代

中 0, 0, 0, 0, 0, 0

华 0, 0, 0, 0, 0, 0

人 1, 0, 0, 0, 0, 0

民 0, 1, 0, 0, 0, 0

共 0, 0, 1, 0, 0, 0

和 0, 0, 0, 1, 0, 0

国 0, 0, 0, 0, 0, 0

为进一步提升该算法，我们可以将字符相同节点(1)的值加上左上角(d[i-1, j-1])的值，这样即可获得最大公用子串的长度。如此一来只需以行号和最大值为条件即可截取最大子串。

　 人民共和时代

中 0, 0, 0, 0, 0, 0

华 0, 0, 0, 0, 0, 0

人 1, 0, 0, 0, 0, 0

民 0, 2, 0, 0, 0, 0

共 0, 0, 3, 0, 0, 0

和 0, 0, 0, 4, 0, 0

国 0, 0, 0, 0, 0, 0

C++ 算法实现Code：

//提取最大公共子串函数（运用LCS即Longest Common Subsequence算法）
string LCS(const string strL1,const string strL2)
{
    //获取两个源串的长度
    int L1=strL1.size(),L2=strL2.size();
    //构建二维矩阵
    vector<vector<int>> x(L2,L1);
    //特殊情况返回
    if(strL1 == strL2)
    {
            return strL1;
    }
        if(strL1.size()==0 || strL2.size()==0)
    {
        return "";
    }
  
    int length=0,index=0;
    for(int i=0;i<L2;i++)
    {
        for(int j=0;j<L1;j++)
        {
            int n=(i>=1 && j>=1)? x[i-1][j-1]:0;
  
            x[i][j]=(strL2[i]==strL1[j])? 1+n:0;
            //获得最长子串末尾数值和位置
            if(x[i][j]>length)
            {
                length=x[i][j];
                index=i;
            }
        }
    }
  
    return string(strL2,index-length+1,length);
}