动态规划 51nod 1183

题目链接:http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1183

1183 编辑距离 

基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题

 收藏

 关注

编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。

例如将kitten一字转成sitting:

sitten (k->s)

sittin (e->i)

sitting (->g)

所以kitten和sitting的编辑距离是3。俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念。

给出两个字符串a,b,求a和b的编辑距离。

Input

第1行:字符串a(a的长度 <= 1000)。
第2行:字符串b(b的长度 <= 1000)。

Output

输出a和b的编辑距离

Input示例

kitten
sitting

Output示例

3

在这里有三种操作,但是可以看成两种,因为增加和删除可以看成一种。假设两个字符数组是str1和str2.我们定义数组dp[i][j]的值就是是把str1[i]和str2[j]之前的字符都编辑成一样需要进行的最少操作数量。现在我想要计算dp[i][j]的值怎么办?那么我们可以分情况讨论。1.通过替换字符到达目前状态,如果str1[i]==str2[j],就不用替换字符就可以从dp[i-1][j-1]的状态到达dp[i][j],那么dp[i][j]=min(dp[i][j],dp[i-1][j-1]),  否则就要替换个字符才可以从dp[i-1][j-1]到达dp[i][j],即dp[i][j]=min(dp[i][j],dp[i-1][j-1]+1).2.通过删除或增加字符到达当前状态,那么dp[i][j]的前一个状态可以有两种,dp[i-1][j]和dp[i][j-1],那么就是dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i][j]).因为str1和str2是从下标0开始的,为了方便和防止下标小于0,那么我们就把dp[i][j]里面的i和j分别表示str1[i-1]和str2[j-1]。代码:
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<cstdio>
#include<string>
#include<deque>
using namespace std;
#define eps 1e-8
#define ll long long
#define INF 0x3f3f3f3f
#define maxn 1005
/*struct point{
    int u,w;
};
bool operator <(const point &s1,const point &s2)
{
    if(s1.w!=s2.w)
    return s1.w>s2.w;
    else
    return s1.u>s2.u;
}*/
char str1[maxn],str2[maxn];
int dp[maxn][maxn];
int main()
{
    while(cin>>str1>>str2)
    {
        int len1=strlen(str1);
        int len2=strlen(str2);
        memset(dp,0x3f,sizeof(dp));

        for(int i=0;i<=len1;i++)//初始化
        dp[i][0]=i;
        for(int i=0;i<=len2;i++)
        dp[0][i]=i;

        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;j++)
            {
                if(str1[i-1]==str2[j-1])//通过替换到达当前状态
                dp[i][j]=min(dp[i][j],dp[i-1][j-1]);
                else
                dp[i][j]=min(dp[i][j],dp[i-1][j-1]+1);

                dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i][j]);//通过删除或者修改到达当前状态
            }
        }
        cout<<dp[len1][len2]<<endl;
    }
    return 0;
}

原文地址:https://www.cnblogs.com/6262369sss/p/9690470.html

时间: 2024-10-05 01:11:21

动态规划 51nod 1183的相关文章

51nod 1183 编辑距离(dp)

题目链接:51nod 1183 编辑距离 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 using namespace std; 5 const int N = 1001; 6 char a[N], b[N]; 7 int dp[N][N];//dp[i][j]:a串的前i个字符转化成b串的前j个字符的最少操作数 8 int main(){ 9 int i, j; 10 scanf(&quo

51nod 1183 - 编辑距离 - [简单DP][编辑距离问题][Levenshtein距离问题]

题目链接:https://www.51nod.com/onlineJudge/questionCode.html#!problemId=1183 编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个所需的最少编辑操作次数.许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符. 例如将kitten一字转成sitting: sitten (k->s) sittin (e->i) sitting (->g) 所以k

51nod 1183 编辑距离

1183 编辑距离 基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题  收藏  关注 编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个所需的最少编辑操作次数.许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符. 例如将kitten一字转成sitting: sitten (k->s) sittin (e->i) sitting (->g) 所以kitten和sitting的编辑

(DP)51NOD 1183 编辑距离

编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个所需的最少编辑操作次数.许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符. 例如将kitten一字转成sitting: sitten (k->s) sittin (e->i) sitting (->g) 所以kitten和sitting的编辑距离是3.俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念. 给出两个字符串a,b,求

51nod 1241 特殊的排序(动态规划)

分析:记数组中最长的连续子串长度为maxlen(数值上连续,位置不一定连续,如2134,最长为3).首先可以证明,n-maxlen次操作可以满足条件,如最长子串最后一个为x<n,则把x+1移到最后,如果是x=n,记子串的第一个为y,把y-1移到最前,每次操作后最长连续子串长度+1,故可以满足条件.接下来证明,这是最少的移动次数.假设还有更少的,说明存在一步移动,最长连续子串长度至少+2,但移走一个元素不增加长度,把这个元素放在最前或最后最多只能增加1,矛盾. 求maxlen动态规划一下,记dp[

51nod 1270 数组的最大代价 思路:简单动态规划

这题是看起来很复杂,但是换个思路就简单了的题目. 首先每个点要么取b[i],要么取1,因为取中间值毫无意义,不能增加最大代价S. 用一个二维数组做动态规划就很简单了. dp[i][0]表示第i个点取1时(第0-i个点)得到的最大代价之和. dp[i][1]表示第i个点取b[i]时(第0-i个点)得到的最大代价之和. 每一个都由前面两个推出. #include <bits\stdc++.h> using namespace std; int a[50005]; int dp[50005][2];

51nod 简单的动态规划

1006 最长公共子序列Lcs 基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题  收藏  关注 给出两个字符串A B,求A与B的最长公共子序列(子序列不要求是连续的). 比如两个串为: abcicba abdkscab ab是两个串的子序列,abc也是,abca也是,其中abca是这两个字符串最长的子序列. Input 第1行:字符串A 第2行:字符串B (A,B的长度 <= 1000) Output 输出最长的子序列,如果有多个,随意输出1个. Input示例 a

51nod 1021 石子归并 (动态规划 简单代码)

题目: 思路:动态规划,递推式子 dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1]);     dp[i][j]表示合并第i到第j个石子需要的最少代价.sum[i]表示前i个石子的价值,sum[j] - sum[i-1]即合成两堆石子((第i到第k合并出的石子),(第k+1到第j合并出的石子)). 但是考虑要求1-4, 需要先求出(1-1,2-4),(1-2,3-4),(1-3,4-4). 所以我们不能直接按横纵

51nod 1052 最大M子段和(动态规划)

分析:记dp[x][s][1]为从第x个数开始,剩余s段可以分,1表示x跟上一段连着,0表示不连着,递推式为dp[x][s][1]=max{dp[x+1][s][1]+a[x],dp[x+1][s][0]},dp[x][s][0]=max{dp[x+1][s-1][1]+a[x],dp[x+1][s][0]}. 1 #include<iostream> 2 #include<cstring> 3 using namespace std; 4 const int maxn=5005;