#include"stdafx.h"
#include <iostream>
#include <vector>
#include <string>
using namespace std;
//算法
int ldistance(const string source,const string target)
{
//step 1
int n=source.length();
int m=target.length();
if (m==0) return n;
if (n==0) return m;
//Construct a matrix
typedef vector< vector<int> > Tmatrix;//定义一个二维的动态数组
Tmatrix matrix(n+1);//有n+1行
for(int i=0; i<=n; i++) matrix[i].resize(m+1);//m+1列
//step 2 Initialize,行列都从1到n,m排列起来
for(int i=1;i<=n;i++) matrix[i][0]=i;
for(int i=1;i<=m;i++) matrix[0][i]=i;
//step 3
for(int i=1;i<=n;i++)
{
const char si=source[i-1];//把source字符串的每个字符都赋给char si中
//step 4
for(int j=1;j<=m;j++)
{
const char dj=target[j-1];//同理把target字符串每个字符赋值给char dj中
//step 5
int cost;
if(si==dj){
cost=0;
}
else{
cost=1;
}
//step 6
const int above=matrix[i-1][j]+1;//当不相等时,上方的数加1
const int left=matrix[i][j-1]+1;//左值也加1
const int diag=matrix[i-1][j-1]+cost;//左对角的数加1
matrix[i][j]=min(above,min(left,diag));//取三个方向最小的值为该位置的值
}
}//step7
return matrix[n][m];//返回最后左下角的值即为两个字符串的距离
}
int main(){
string s;
string d;
cout<<"source=";
cin>>s;
cout<<"diag=";
cin>>d;
int dist=ldistance(s,d);
cout<<"dist="<<dist<<endl;
system("pause");
return 0;
}
这里也是看了其他博主的代码,他写的很好,我就贴出来给大家看看
一个字符串可以通过“增加一个字符”,“删除一个字符”,“替换一个字符”,从而得到另一个字符串,假设我们从字符串A转换为字符串B,前面3种操作所执行的最少次数就是A和B的相似度。求该最小次数。
如 abc adc 度为 1
ababababa babababab 度为 2
abcd acdb 度为2
那是相当有趣啊,哈哈,博客中介绍了这个问题最常用的解决算法--Levenshtein Distance,下面就来介绍下这个算法如何来解决这个问题(部分摘自维基百科http://en.wikipedia.org/wiki/Levenshtein_distance)
假设我们可以使用d[ i , j ]个步骤(可以使用一个二维数组保存这个值),表示将串s[ 1…i ] 转换为 串t [ 1…j ]所需要的最少步骤个数,那么,在最基本的情况下,即在i等于0时,也就是说串s为空,那么对应的d[0,j] 就是 增加j个字符,使得s转化为t,在j等于0时,也就是说串t为空,那么对应的d[i,0] 就是 减少 i个字符,使得s转化为t。
然后我们考虑一般情况,加一点动态规划的想法,我们要想得到将s[1..i]经过最少次数的增加,删除,或者替换操作就转变为t[1..j],那么我们就必须在之前可以以最少次数的增加,删除,或者替换操作,使得现在串s和串t只需要再做一次操作或者不做就可以完成s[1..i]到t[1..j]的转换。所谓的“之前”分为下面三种情况:
1)我们可以在k个操作内将 s[1…i] 转换为 t[1…j-1]
2)我们可以在k个操作里面将s[1..i-1]转换为t[1..j]
3)我们可以在k个步骤里面将 s[1…i-1] 转换为 t [1…j-1]
针对第1种情况,我们只需要在最后将 t[j] 加上s[1..i]就完成了匹配,这样总共就需要k+1个操作。
针对第2种情况,我们只需要在最后将s[i]移除,然后再做这k个操作,所以总共需要k+1个操作。
针对第3种情况,我们只需要在最后将s[i]替换为 t[j],使得满足s[1..i] == t[1..j],这样总共也需要k+1个操作。而如果在第3种情况下,s[i]刚好等于t[j],那我们就可以仅仅使用k个操作就完成这个过程。
最后,为了保证得到的操作次数总是最少的,我们可以从上面三种情况中选择消耗最少的一种最为将s[1..i]转换为t[1..j]所需要的最小操作次数。
更加具体的算法如下:
Step | Description |
1 | Set n to be the length of s. 构造 行数为m+1 列数为 n+1 的矩阵 , 用来保存完成某个转换需要执行的操作的次数,将串s[1..n] 转换到 串t[1…m] 所需要执行的操作次数为matrix[n][m]的值 |
2 | Initialize the first row to 0..n. 初始化matrix第一行为0到n,第一列为0到m。 Matrix[0][j]表示第1行第j-1列的值,这个值表示将串s[1…0]转换为t[1..j]所需要执行的操作的次数,很显然将一个空串转换为一个长度为j的串,只需要j次的add操作,所以matrix[0][j]的值应该是j,其他值以此类推。 |
3 | Examine each character of s (i from 1 to n). |
4 | Examine each character of t (j from 1 to m). |
5 | If s[i] equals t[j], the cost is 0. 将串s和串t的每一个字符进行两两比较,如果相等,则让cost为0,如果不等,则让cost为1(这个cost后面会用到) |
6 | Set cell d[i,j] of the matrix equal to the minimum of: 如果我们可以在k个操作里面将s[1..i-1]转换为t[1..j],那么我们就可以将s[i]移除,然后再做这k个操作,所以总共需要k+1个操作。 b. The cell immediately to the left plus 1: d[i,j-1] + 1. 如果我们可以在k个操作内将 s[1…i] 转换为 t[1…j-1] ,也就是说d[i,j-1]=k,那么我们就可以将 t[j] 加上s[1..i],这样总共就需要k+1个操作。 c. The cell diagonally above and to the left plus the cost: d[i-1,j-1] + cost. 如果我们可以在k个步骤里面将 s[1…i-1] 转换为 t [1…j-1],那么我们就可以将s[i]转换为 t[j],使得满足s[1..i] == t[1..j],这样总共也需要k+1个操作。(这里加上cost,是因为如果s[i]刚好等于t[j],那么就不需要再做替换操作,即可满足,如果不等,则需要再做一次替换操作,那么就需要k+1次操作) 因为我们要取得最小操作的个数,所以我们最后还需要将这三种情况的操作个数进行比较,取最小值作为d[i,j]的值 |
7 | After the iteration steps (3, 4, 5, 6) are complete, the distance is found in cell d[n,m]. 然后重复执行3,4,5,6,最后的结果就在d[n,m]中 |
下面是另外一个具体详解 都挺好的 给大家分享分享:
这个算法实现起来很简单
1.百度百科介绍:
Levenshtein 距离,又称编辑距离,指的是两个字符串之间,由一个转换成另一个所需的最少编辑操作次数。
许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。
编辑距离的算法是首先由俄国科学家Levenshtein提出的,故又叫Levenshtein Distance。
2.用途
模糊查询
3.实现过程
a.首先是有两个字符串,这里写一个简单的 abc和abe
b.将字符串想象成下面的结构。
A处 是一个标记,为了方便讲解,不是这个表的内容。
abc | a | b | c | |
abe | 0 | 1 | 2 | 3 |
a | 1 | A处 | ||
b | 2 | |||
e | 3 |
c.来计算A处 出得值
它的值取决于:左边的1、上边的1、左上角的0.
按照Levenshtein distance的意思:
上面的值和左面的值都要求加1,这样得到1+1=2。
A处 由于是两个a相同,左上角的值加0.这样得到0+0=0。
这是后有三个值,左边的计算后为2,上边的计算后为2,左上角的计算为0,所以A处 取他们里面最小的0.
d.于是表成为下面的样子
abc | a | b | c | |
abe | 0 | 1 | 2 | 3 |
a | 1 | 0 | ||
b | 2 | B处 | ||
e | 3 |
在B处 会同样得到三个值,左边计算后为3,上边计算后为1,在B处 由于对应的字符为a、b,不相等,所以左上角应该在当前值的基础上加1,这样得到1+1=2,在(3,1,2)中选出最小的为B处的值。
e.于是表就更新了
abc | a | b | c | |
abe | 0 | 1 | 2 | 3 |
a | 1 | 0 | ||
b | 2 | 1 | ||
e | 3 | C处 |
C处 计算后:上面的值为2,左边的值为4,左上角的:a和e不相同,所以加1,即2+1,左上角的为3。
在(2,4,3)中取最小的为C处 的值。
f.于是依次推得到
a | b | c | ||
0 | 1 | 2 | 3 | |
a | 1 | A处 0 | D处 1 | G处 2 |
b | 2 | B处 1 | E处 0 | H处 1 |
e | 3 | C处 2 | F处 1 | I处 1 |
I处: 表示abc 和abe 有1个需要编辑的操作。这个是需要计算出来的。
同时,也获得一些额外的信息。
A处: 表示a 和a 需要有0个操作。字符串一样
B处: 表示ab 和a 需要有1个操作。
C处: 表示abe 和a 需要有2个操作。
D处: 表示a 和ab 需要有1个操作。
E处: 表示ab 和ab 需要有0个操作。字符串一样
F处: 表示abe 和ab 需要有1个操作。
G处: 表示a 和abc 需要有2个操作。
H处: 表示ab 和abc 需要有1个操作。
I处: 表示abe 和abc 需要有1个操作。
g.计算相似度
先取两个字符串长度的最大值maxLen,用1-(需要操作数除maxLen),得到相似度。
例如abc 和abe 一个操作,长度为3,所以相似度为1-1/3=0.666。
5.猜测原理
为什么这样就能算出相似度了?
首先在连续相等的字符就可以考虑到
红色是取值的顺序。
1.今天周一 天周一
天 | 周 | 一 | ||
0 | 1 | 2 | 3 | |
今 | 1 | 1 | 2 | 3 |
天 | 2 | 1 | 2 | 3 |
周 | 3 | 2 | 1 | 3 |
一 | 4 | 3 | 3 | 1 |
实现是去掉“今”,一步完成。
2.听说马上就要放假了 你听说要放假了
你 | 听 | 说 | 要 | 放 | 假 | 了 | ||
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | |
听 | 1 | 1 | 1 | 2 | 3 | 4 | 5 | 6 |
说 | 2 | 2 | 2 | 1 | 2 | 3 | 4 | 5 |
马 | 3 | 3 | 3 | 2 | 2 | 3 | 4 | 5 |
上 | 4 | 4 | 4 | 3 | 3 | 3 | 4 | 5 |
就 | 5 | 5 | 5 | 4 | 4 | 4 | 4 | 5 |
要 | 6 | 6 | 6 | 5 | 4 | 5 | 5 | 5 |
放 | 7 | 7 | 7 | 6 | 5 | 4 | 5 | 6 |
假 | 8 | 8 | 8 | 7 | 6 | 5 | 4 | 6 |
了 | 9 | 9 | 9 | 8 | 7 | 6 | 6 | 4 |
这两个字符串是:
去掉“你”,加上“马上就”,总共四步操作。
3.还是没弄懂
6.结束
算法优化空间很大。
最后也没弄懂为什么这样算能算出相似度。