计算字符间距的C语言,计算字符串的距离

最新推荐文章于 2021-12-16 10:37:42 发布

青知字幕组

最新推荐文章于 2021-12-16 10:37:42 发布

阅读量1.7k

点赞数

文章标签：计算字符间距的C语言

python solution: def editDistance(str1, str2):

len1, len2 = len(str1) + 1, len(str2) + 1

dp = [[0 for i in range(len2)] for j in range(len1)]

for i in range(len1):

dp[i][0] = i

for j in range(len2):

dp[0][j] = j

for i in range(1, len1):

for j in range(1, len2):

dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (str1[i - 1] != str2[j - 1]))

return dp[-1][-1]

while True:

try:

print(editDistance(input(), input()))

except:

break

发表于 2017-10-17 14:57:35

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

while(in.hasNext()){

String strA = in.next();

String strB = in.next();

int ic = 1;

int dc = 1;

int rc = 1;

int cost = strEditCost(strA, strB, ic, dc, rc);

System.out.println(cost);

}

in.close();

}

public static int strEditCost(String strA, String strB, int ic, int dc, int rc){

/* 字符串之间的距离，编辑距离，将strA编辑成strB所需的最小代价

* 编辑操作包括插入一个字符、删除一个字符、替换一个字符

* 分别对应的代价是ic、dc、rc，insert cost、delete cost、replace cost

* strA[x-1]代表strA的第x个字符，注意下标是从0开始的,strA[y-1]代表strA的第y个字符

* 定义一个代价矩阵为(N+1)*(M+1)，M N 表示strA strB的长度

* dp[x][y]表示strA的前x个字符串编辑成 strB的前y个字符所花费的代价

* dp[x][y]是下面几种值的最小值：

* 1、dp[x][y] = dp[x-1][y] + dc

* dp[x-1][y]将strA的前x-1个字符编辑成strB的前y个字符的代价已知，

* 那么将将strA的前x个字符编辑成strB的前y个字符的代价dp[x][y]就是dp[x-1][y] + dc

* 相当于strA的前x-1个字符编辑成strB的前y个字符，现在变成了strA的前x个字符，增加了一个字符，要加上删除代价

* 2、dp[x][y] = dp[x][y-1] + ic

* dp[x][y-1]将strA的前x个字符编辑成strB的前y-1个字符的代价已知，

* 现在变为strB的前y个字符，相应的在strA前x个操作代价的基础上插入一个字符

* 3、dp[x][y] = dp[x-1][y-1]

* dp[x-1][y-1]将strA的前x-1个字符编辑成strB的前y-1个字符的代价已知，

* strA的第x个字符和strB的第y个字符相同，strA[x-1] == strB[y-1]，没有引入操作

* 4、dp[x][y] = dp[x-1][y-1] + rc

* strA的第x个字符和strB的第y个字符不相同，strA[x-1] ！= strB[y-1]，

* 在strA的前x-1个字符编辑成strB的前y-1个字符的代价已知的情况下，

* 计算在strA的前x字符编辑成strB的前y个字符的代价需要加上替换一个字符的代价

* */

int m = strA.length();

int n = strB.length();

int[][] dp = new int[m + 1][n + 1];

for (int i = 1; i <= n; i++) dp[0][i] = i*ic;

for (int i = 1; i <= m; i++) dp[i][0] = i*dc;

for (int x = 1; x <= m; x++) {

for (int y = 1; y <= n; y++) {

int cost1 = dp[x-1][y] + dc;

int cost2 = dp[x][y-1] + ic;

int cost3 = 0;

if(strA.charAt(x-1) == strB.charAt(y-1))

cost3 = dp[x-1][y-1];

else

cost3 = dp[x-1][y-1] + rc;

dp[x][y] = Math.min(cost1, cost2);

dp[x][y] = Math.min(dp[x][y], cost3);

}

return dp[m][n];

}

编辑于 2017-06-28 12:54:18

//思路主要：

如果两个串的第一个字符相同

，如A=xabcdae和B=xfdfa，只要计算

A[2,…,7]=abcdae和B[2,…,5]=fdfa的距离就可以了。

如果两个串的第一个字符不相同

，那么可以进行如下的操作：

1．删除A串的第一个字符，然后计算A[2,…,lenA]和B[1,…,lenB]的距离。

2．删除B串的第一个字符，然后计算A[1,…,lenA]和B[2,…,lenB]的距离。

3．修改A串的第一个字符为B串的第一个字符，然后计算A[2,…,lenA]和

B[2,…,lenB]的距离。

4．修改B串的第一个字符为A串的第一个字符，然后计算A[2,…,lenA]和

B[2,…,lenB]的距离。

5．增加B串的第一个字符到A串的第一个字符之前，然后计算

A[1,…,lenA]和B[2,…,lenB]的距离。

6．增加A串的第一个字符到B串的第一个字符之前，然后计算

A[2,…,lenA]和B[1,…,lenB]的距离。

动态规划思路为：

* 设Ai为字符串A(a1a2a3 … am)的前i个字符(即为a1,a2,a3 … ai)

* 设Bj为字符串B(b1b2b3 … bn)的前j个字符(即为b1,b2,b3 … bj)

* 设 L(i,j)为使两个字符串和Ai和Bj相等的最小操作次数。

* 当ai==bj时显然 L(i,j) = L(i-1,j-1)

* 当ai!=bj时

* 若将它们修改为相等，则对两个字符串至少还要操作L(i-1,j-1)次

* 若删除ai或在bj后添加ai，则对两个字符串至少还要操作L(i-1,j)次

* 若删除bj或在ai后添加bj，则对两个字符串至少还要操作L(i,j-1)次

* 此时L(i,j) = min( L(i-1,j-1), L(i-1,j), L(i,j-1) ) + 1

* 显然，L(i,0)=i，L(0,j)=j, 再利用上述的递推公式，可以直接计算出L(i,j)值。

package com.wenjie.huawei;

import java.util.Scanner;

public class CalStringDistance {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

while (sc.hasNext()) {

String str1 = sc.nextLine();

String str2 = sc.nextLine();

System.out.println(stringDistance(str1.toCharArray(),str2.toCharArray()));

}

private static int stringDistance(char[] a, char[] b) {

int[][] len = new int[a.length + 1][b.length + 1];

for (int i = 0; i < len.length; i++) {

len[i][0] = i;

}

for (int j = 0; j < len[0].length; j++) {

len[0][j] = j;

}

for (int i = 1; i < len.length; i++) {

for (int j = 1; j < len[0].length; j++) {

if (a[i - 1] == b[j - 1]) {

len[i][j] = len[i - 1][j - 1];

} else {

len[i][j] = Math.min(Math.min(len[i - 1][j], len[i - 1][j - 1]), len[i][j - 1]) + 1;

}

return len[len.length - 1][len[0].length - 1];

}

编辑于 2017-06-14 21:27:16

//典型的动态规划优化编辑器问题

//参考博客 http://blog.csdn.net/shizheng163/article/details/50988023

#include

using namespace std;

int calStringDistance(string a,string b){

int n = (int)a.size(),m = (int)b.size();

vector>dp(n+1,vector(m+1,0));

dp[0][0] = 0;//dp[x][y]代表将a字符串前x个字符修改成b字符串前y个字符

for (int i=1; i<=m; ++i) dp[0][i] = i;

for (int i=1; i<=n; ++i) dp[i][0] = i;

for (int i=1; i<=n; ++i) {

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

int one = dp[i-1][j] +1,two = dp[i][j-1]+1,three = dp[i-1][j-1];

if(a[i-1]!=b[j-1]) three+=1;

dp[i][j] = min(min(one,two),three);

}

return dp[n][m];

}

int main(){

string a,b;

while(cin>>a>>b)

cout<

return 0;

}

编辑于 2016-04-01 21:30:35

def edit_distance(s1,s2):

len1 = len(s1) + 1

len2 = len(s2) + 1

edit = [[i + j for j in range(len2)] for i in range(len1)]

for i in range(1,len1):

for j in range(1,len2):

if s1[i-1] == s2[j-1]:

d = 0

else:

d = 1

edit[i][j] = min(edit[i][j-1]+1,edit[i-1][j]+1,edit[i-1][j-1]+d)

return edit[-1][-1]

while True:

try:

print(edit_distance(input(), input()))

except:break

推荐大家看个文章，什么都懂了

发表于 2020-05-14 15:39:57

#include

using namespace std;

//空间可以优化成O(n)

int main() {

string s1, s2;

while (cin >> s1 >> s2) {

vector> dp(s1.size() + 1, vector(s2.size() + 1, 0));

for (int i = 1; i <= s2.length(); i++) dp[0][i] = i;

for (int i = 1; i <= s1.length(); i++) dp[i][0] = i;

for(int i=1;i<=s1.length();i++)

for (int j = 1; j <= s2.length(); j++) {

int min1 = min(dp[i - 1][j], dp[i][j - 1]) + 1;

dp[i][j] = min((s1[i - 1] == s2[j - 1] ? 0 : 1) + dp[i - 1][j - 1], min1);

}

cout << dp[s1.size()][s2.size()] << endl;

}

发表于 2017-03-17 16:16:10

本题删除，替换，插入代价全是 1

#include

using namespace std;

int calStringDistance(string A,string B);

int main()

{

string charA;

string charB;

while(getline(cin,charA)&&getline(cin,charB))

{

cout<

}

return 0;

}

int calStringDistance(string A,string B)

{

int row=A.size();//字符串A的长度

int col=B.size();//字符串B的长度

int **dp=new int*[row+1];//动态创建一个二维数组

for(int i=0;i

{

dp[i]=new int[col+1]();

}

dp[0][0]=0;//这里代价是0，也就是空字符到空字符，不需要任何编辑

for(int i=1;i

{

dp[i][0]=i;

}

for(int j=1;j

{

dp[0][j]=j;

}

for(int i=1;i

{

for(int j=1;j

{

if(A[i-1]==B[j-1])

{

dp[i][j]=dp[i-1][j-1];//如果i和j位置字符相同，说明i和j位置的字符不需要编辑。dp[i][j]=dp[i-1][j-1]

}

else

{

dp[i][j]=dp[i-1][j-1]+1;//这里需要一个替换代价

}

dp[i][j]=min(dp[i-1][j]+1,dp[i][j]);

dp[i][j]=min(dp[i][j],dp[i][j-1]+1);

}

return dp[row][col];

}

发表于 2016-04-01 11:22:56

方法：动态规划

状态：

子状态：word1的前1，2，3，...m个字符转换成word2的前1，2，3，...n个字符需要的编辑距离

F(i,j):word1的前i个字符于word2的前j个字符的编辑距离

状态递推：

F(i,j) = min { F(i-1,j)+1, F(i,j-1) +1, F(i-1,j-1) +(w1[i]==w2[j]?0:1) }

上式表示从删除，增加和替换操作中选择一个最小操作数

F(i-1,j): w1[1,...,i-1]于w2[1,...,j]的编辑距离，删除w1[i]的字符--->F(i,j)

F(i,j-1): w1[1,...,i]于w2[1,...,j-1]的编辑距离，增加一个字符--->F(i,j)

F(i-1,j-1): w1[1,...,i-1]于w2[1,...,j-1]的编辑距离，如果w1[i]与w2[j]相同，

不做任何操作，编辑距离不变，如果w1[i]与w2[j]不同，替换w1[i]的字符为w2[j]--->F(i,j)

初始化：

初始化一定要是确定的值，如果这里不加入空串，初始值无法确定

F(i,0) = i :word与空串的编辑距离，删除操作

F(0,i) = i :空串与word的编辑距离，增加操作

返回结果：F(m,n)

注：字符串类的动态规划，可引入空串进行初始化

#include

using namespace std;

int editDistance(string str1, string str2){

if(str1.empty() || str2.empty()){

return max(str1.size(), str2.size());

}

const int m = str1.size() + 1;

const int n = str2.size() + 1;

vector> F(m, vector(n, 0));

for(int i = 0; i

F[i][0] = i;

}

for(int j = 0; j

F[0][j] = j;

}

for(int i = 1; i

for(int j = 1; j

// 从删除，增加和替换操作中选择一个最小操作数

F[i][j] = min(min(F[i - 1][j] + 1, F[i][j - 1] + 1), F[i - 1][j - 1] + (str1[i - 1] == str2[j - 1] ? 0 : 1));

}

return F[m - 1][n - 1];

}

int main(){

string str1, str2;

while(cin >> str1 >> str2){

cout <

}

return 0;

}

发表于 2020-06-19 22:22:00

计算莱文斯坦距离

递归思路非常简单，逐个考察每对字符，相同则同时继续考察下一对，不同则考虑替换、插入或删除(由于两字符串是相对关系所以其实算是一种)，当一方字符串已经考察完毕，另一方剩下的字符数量加入

不足的是本题中可能存在运算超时，所以想要通过示例需要将递归过程用数组保存并进行递推，不过递归思路贴出来可供大家参考 int getDistance(char str1[],char str2[],int k1,int k2,int len1,int len2){

if (len1-k1==0) //当其中某个字符串剩余考察长度为0的时候,编辑距离就是另一个字符串的长度

return len2-k2;

else if (len2-k2==0)

return len1-k1;

else {

if (str1[k1]==str2[k2]) //当前字符比较相等的时候,继续从两字符串下一位置考察

return getDistance(str1, str2, k1+1, k2+1, len1, len2);

else { //当前字符比较不等的时候

//分别考虑替换(均从两字符串下一位置考察,当前位置视为替换)

int a=getDistance(str1, str2, k1+1, k2+1, len1, len2)+1;

//插入或删除(一方停留当前位置,另一方考察下一位置)

int b=getDistance(str1, str2, k1, k2+1, len1, len2)+1;

int c=getDistance(str1, str2, k1+1, k2, len1, len2)+1;

return a

}

int main(){

int getDistance(char [],char [],int ,int ,int ,int );

char str1[100],str2[100];

while (~scanf("%s %s",str1,str2)) {

printf("%d\n",getDistance(str1, str2, 0, 0, (int)strlen(str1), (int)strlen(str2))); //初始考察位置均为0

}

return 0;

}

编辑于 2020-05-20 11:30:58

#include

(720)#include

using namespace std;

int main()

{

string A,B;

while(cin>>A>>B)

{

int len_A=A.size();

int len_B=B.size();

if(len_A==0||len_B==0)

return len_A+len_B;

vectorrecord(len_B+1,0);

for(int j=0;j<=len_B;j++)

record[j]=j;

for(int i=1;i<=len_A;i++)

{

int lu=record[0];record[0]=i;

for(int j=1;j<=len_B;j++)

{

int k=record[j];

if(A[i-1]==B[j-1])

lu-=1;

record[j]=1+min(record[j],min(record[j-1],lu));

lu=k;

}

cout<

}

一维数组dp省内存,一维数组要替换的数就二维数组dp的上面那个数，左边的数也就是一维数组左边的，

只是左上的数不能体现，可以单独用变量表示lu,而k表示存储下一个数的左上，最后赋值给lu

发表于 2020-04-09 13:55:58

如何计算编辑距离:

1.两字字串都为空，编辑距离为0

2.当其中一个为空时，编辑距离为另外一个字串的长度。

3.当两个字串非空时(长度分别为i 和 j时)，取下面3种情况最小值：

3.1 当i-1 和 j的编辑距离已知时，直接+1 为 i和j的编辑距离

3.2 当i 和 j-1的编辑距离已知时，直接+1 为 i和j的编辑距离

3.3 当i-1 和 j-1的编辑距离已知时，如果i字符和j字符相等则+0，如果不相等则+1为 i和j的编辑距离。

应该用动态规划：

int dp[m+1][n+1] //定义长度为i的字串和长度为j的字串之间的编辑距离

两个字符串最前面插入一个空字符，初始化[i][0] base case 为i，初始化[0][j] base case 为j；

编写状态转移方程。

int cal_distance(string sline1,string sline2)

{

if ((sline1.empty())&&(sline2.empty())){

return 0;

}

if ((sline1.empty())&&(!sline2.empty())){

return sline2.size();

}

if ((!sline1.empty())&&(sline2.empty())){

return sline1.size();

}

sline1.insert(sline1.begin(),' ');

sline2.insert(sline2.begin(),' ');

int m = sline1.size();

int n = sline2.size();

vector> dp(m, vector(n,0));//定义长度为i的字串和长度为j的字串之间的编辑距离

for (int i=0;i

dp[i][0] = i;

}

for (int j=0;j

dp[0][j] = j;

}

for (int i=1;i

for (int j=1;j

int add;

if (sline1[i] == sline2[j]){

add = 0;

}

else{

add = 1;

}

int dp1 = dp[i-1][j-1] + add;

int dp2 = dp[i-1][j]+1;

int dp3 = dp[i][j-1]+1;

if (dp1>dp2){

dp1 = dp2;

}

if (dp1>dp3){

dp1 = dp3;

}

dp[i][j] = dp1;

}

return dp[m-1][n-1];

}

int _tmain(int argc, _TCHAR* argv[])

{

string sline1, sline2;

while(cin >> sline1)

{

cin >> sline2;

int length = cal_distance(sline1,sline2);

cout <

}

return 0;

}

发表于 2021-04-18 16:27:17

动态规划，dp[i][j]代表i到j的编辑距离

public static void main(String[] args){

Scanner in = new Scanner(System.in);

while(in.hasNext()){

String a = in.nextLine();

String b = in.nextLine();

int m = a.length();

int n = b.length();

int[][] dp = new int[m + 1][n + 1];

//初始化状态

for(int i = 1;i <= m;i++){

dp[i][0] = i;

}

for(int j = 1;j <= n;j++){

dp[0][j] = j;

}

for(int i = 1;i <= m;i++){

for(int j = 1;j <= n;j++){

if(a.charAt(i - 1) == b.charAt(j - 1)){

dp[i][j] = dp[i - 1][j - 1];

}else{

dp[i][j] = Math.min(dp[i - 1][j - 1],Math.min(dp[i - 1][j],dp[i][j - 1])) + 1;

}

System.out.println(dp[m][n]);

}

发表于 2021-04-15 15:37:45

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner cin = new Scanner(System.in);

while (cin.hasNext()) {

String s1 = " " + cin.next(), s2 = " " + cin.next();

System.out.println(calStringDistance(s1, s2));

}

public static int calStringDistance(String charA, String charB) {

int n = charA.length(), m = charB.length();

int[][] lev = new int[n][m];

int cost;

for (int i = 0; i

for (int j = 0; j

for (int i = 1; i

for (int j = 1; j

char ch1 = charA.charAt(i), ch2 = charB.charAt(j);

if (ch1 == ch2) cost = 0;

else cost = 1;

lev[i][j] = getMin(lev[i - 1][j] + 1, lev[i][j - 1] + 1, lev[i - 1][j - 1] + cost);

}

return lev[n - 1][m - 1];

}

public static int getMin(int a, int b, int c) {

a = Math.min(a, b);

b = Math.min(b, c);

return Math.min(a, b);

}

发表于 2020-08-22 20:30:14

最小编辑距离，经典的动态规划问题之一，类似的还有最大公共子串，最大公共序列，最大递增序列，01

背包问题等等

#include

using namespace std;

int main(){

string s1,s2;

while(cin>>s1>>s2){

int len1=s1.size();

int len2=s2.size();

vector>dp(len1+1,vector(len2+1,0));

for(int i=1;i<=len1;i++){

dp[i][0]=i;

}

for(int j=1;j<=len2;j++){

dp[0][j]=j;

}

dp[0][0]=0;

for(int i=1;i<=len1;i++){

for(int j=1;j<=len2;j++){

if(s1[i-1]==s2[j-1])

dp[i][j]=dp[i-1][j-1];

else{

int tem=min(dp[i-1][j],dp[i][j-1]);

dp[i][j]=min(dp[i-1][j-1],tem)+1;

}

cout<

}

return 0;

}

发表于 2020-02-16 20:08:55

动态规划算法之一,编辑距离。不要搞得这么复杂吓死人，看帖了解距离矩阵，按公式编程即可。

贴出参考的帖子地址：

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

while(in.hasNext()){

String strA = in.next();

String strB = in.next();

int cost = strEditCost(strA, strB);

System.out.println(cost);

}

in.close();

}

public static int strEditCost(String strA, String strB){

int m = strA.length() + 1;

int n = strB.length() + 1;

int[][] dp = new int[m][n];

// 初始化0列0行先,这个距离是可以预先知道的

for(int i = 0;i

dp[i][0] = i;

}

for(int j = 0;j

dp[0][j] = j;

}

// 当 i,j都是大于0时

for(int i = 1;i

for(int j=1;j

int cout1 = Math.min(dp[i-1][j] + 1,dp[i][j-1] + 1);

int dc = 1;

if(strA.charAt(i-1) == strB.charAt(j-1)) {

dc = 0;

}

int cout2 = Math.min(cout1,dp[i-1][j-1]+dc);

dp[i][j] = cout2;

}

return dp[m-1][n-1];

}

发表于 2019-11-02 23:47:13

动态规划 import java.util.*;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

while(in.hasNext()) {

String str1 = in.nextLine();

String str2 = in.nextLine();

System.out.println(calStringDistance(str1,str2));

}

private static int calStringDistance(String str1,String str2){

int M = str1.length();

int N = str2.length();

//dp[i][j] 代表 str1[0...i-1] 编辑成 str2[0...j-1] 的最小代价

int[][] dp = new int[M+1][N+1];

//将 "" 编辑成 ""

dp[0][0] = 0;

//将 str1[0...i-1] 编辑成 "" 的代价

for(int i = 1;i < M+1;i++){

dp[i][0] = i;

}

//将 "" 编辑成 str2[0...j-1] 的代价

for(int j = 1;j < N+1;j++){

dp[0][j] = j;

}

for(int i = 1;i < M+1;i++){

for(int j = 1;j < N+1;j++){

//str1[0...i-1] 先编辑成str1[0...i-2],然后由str1[0...i-2]编辑成str2[0...j-1]

int c1 = 1 + dp[i-1][j];

//str1[0...i-1] 先编辑成str2[0...j-2],然后由str2[0...j-2]编辑成str2[0...j-1]

int c2 = dp[i][j-1] + 1;

//如果str1[i-1] != str2[j-1]。先把str1[0...i-1]中str1[0...i-2]的部分变为str2[0...j-2]

//然后把字符str1[i-1]替换成str2[j-1]

int c3 = dp[i-1][j-1] + 1;

//如果str1[i-1] == str2[j-1]。把str1[0...i-1]中str1[0...i-2]的部分变为str2[0...j-2]即可

int c4 = dp[i-1][j-1];

if(str1.charAt(i-1) != str2.charAt(j-1)){

dp[i][j] = Math.min(Math.min(c1,c2),c3);

}else {

dp[i][j] = Math.min(Math.min(c1,c2),c4);

}

return dp[M][N];

}

发表于 2019-08-22 16:24:11

#include

using namespace std;

int main(){

string a,b;

while(cin>>a>>b)

{

int n = a.size(),m = b.size();

vector>dp(n+1,vector(m+1));/*dp[x][y]代表将a字符串的前x个字符(从1编号，a的前1个字符为a[0],

前两个字符为a[0]和a[1])转换成b字符串的前y个字符*/

for (int i=0; i<=n; i++) dp[i][0] = i;

for (int j=0; j<=m; j++) dp[0][j] = j;

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

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

{

int d1 = dp[i-1][j] +1,d2 = dp[i][j-1]+1,d3 = dp[i-1][j-1];

if(a[i-1]!=b[j-1]) d3+=1; //注意由于a的前i-1个字符时从1编号，则第i个字符也是从1编号，为a[i-1]，同理b[j-1]

dp[i][j] = min(min(d1,d2),d3);

}

cout<

}

return 0;

}

发表于 2018-07-08 01:01:58

import java.util.*;

public class Main{

public static void main(String[] args){

Scanner input=new Scanner(System.in);

while(input.hasNext()){

String s1=input.nextLine();

String s2=input.nextLine();

System.out.println(stringDistance(s1.toCharArray(), s2.toCharArray()));

}

public static int stringDistance(char[] a, char[] b){

int[][] len = new int[a.length + 1][b.length + 1];

for (int i = 0; i < len.length; i++) {

len[i][0] = i;

}

for (int j = 0; j < len[0].length; j++) {

len[0][j] = j;

}

for (int i = 1; i < len.length; i++) {

for (int j = 1; j < len[0].length; j++) {

if (a[i - 1] == b[j - 1]) {

len[i][j] = len[i - 1][j - 1];

} else {

len[i][j] = Math.min(Math.min(len[i - 1][j], len[i - 1][j - 1]), len[i][j - 1]) + 1;

}

return len[len.length - 1][len[0].length - 1];

}

发表于 2018-06-29 15:56:37

import java.util.Scanner;

public class P052StringDistance {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

while(sc.hasNext()){

String strA = sc.next();

String strB = sc.next();

System.out.println(calStrDis(strA, strB, strA.length(), strB.length()));

}

sc.close();

}

public static int calStrDis(String strA, String strB, int m, int n) {

int[][] dp = new int[m+1][n+1];

for (int i = 0; i <= m; i++) {

for (int j = 0; j <= n; j++) {

if(i == 0)//strA为空。

dp[i][j] = j;

else if(j == 0)//strB为空。

dp[i][j] = i;

else if(strA.charAt(i - 1) == strB.charAt(j - 1))//strA和strB最后一个字符相同。

dp[i][j] = dp[i-1][j-1];

else//strA和strB最后一个字符不同。

dp[i][j] = 1 + min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]);//strA的所有操作：插入，删除，替换。 }

}

return dp[m][n];

/*//直接递归，运行超时。

if(m == 0) return n;

if(n == 0) return m;

if(strA.charAt(m - 1) == strB.charAt(n - 1))

return calStrDis(strA, strB, m - 1, n - 1);

return 1 + min(calStrDis(strA, strB, m, n - 1), calStrDis(strA, strB, m - 1, n), calStrDis(strA, strB, m - 1, n - 1));

}

public static int min(int x, int y, int z) {

if(x < y && x < z)

return x;

else if(y < x && y < z){

return y;

else

return z;

}

发表于 2018-06-12 22:55:51

import java.util.Scanner;

public class Main{

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

while(in.hasNextLine()){

String s1=in.nextLine();

String s2=in.nextLine();

System.out.println(calStringDistance(s1,s2));

}

private static int calStringDistance(String s1, String s2) {

int len1 = s1.length();

int len2 = s2.length();

char[] c1 = s1.toCharArray();

char[] c2 = s2.toCharArray();

if(len1==0){

return len2;

}

if(len2 ==0){

return len1;

}

int[][] a = new int[len1+1][len2+1];

for(int i=0;i

a[i][0]=i;

}

for(int j=0;j

a[0][j] =j;

}

for(int i=1;i

for(int j=1;j

int temp=Math.min(a[i-1][j]+1, a[i][j-1]+1);

int num=c1[i-1]==c2[j-1]?0:1;

a[i][j]=Math.min(temp, a[i-1][j-1]+num);

}

return a[len1][len2];

}

编辑于 2017-04-17 16:50:34

青知字幕组

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫