线性dp例题

这里是Joe本人的学习笔记，如果能帮助到你，那我受宠若惊！

先给出链接：

P2758 编辑距离 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

这里感谢

@4396瞎

@Starlight_Glimmer

@秋云暗几重

这几位大佬的详细讲解！

下面引用大佬的原文：

做动态规划的题一般分为四个步骤：确定子问题—>定义状态—>转移方程—>避免重复求解

用在这一题当中我的思路如下：

1.确定子问题：

由于对于字符串的操作只有4种情况（删除，添加、更改、不变），所以该题的子问题就是进行了这4种操作后的A字符串变为B字符串需要多少步。

2.定义状态：

也就是说递归的dp函数需要哪些参数，参数越少越好因为需要建memo。后来想到dp（i，j）代表字符串A的前i个字符（包括第i个）变为字符串B的前j个（包括第j个）需要多少步。也就是说解出来dp（lenA，lenB）就可以了。

3.转移方程：

删：dp(i-1，j)+1 //字符串A的前i-1个字符变为字符串B的前j个需要多少步 【把字符串的第i个字符（最后一个）删除了】，删除需要一步因此加1

添：dp(i，j-1)+1 //将B[j]字符加在A字符串的最后面即添加，同样可以理解为将B[j]字符删掉（因为不用再考虑了）。

//字符串A的前i个字符变为字符串B的前j-1个需要多少步 添加需要一步因此加1

替：dp(i-1，j-1)+1 //字符串A和B的最后两个都相等了，因此都不用再考虑

//字符串A的前i-1个字符变为字符串B的前j-1个需要多少步 添加需要一步因此加1

不变：dp（i-1，j-1）//字符串A和B的最后两个都相等，不考虑。感性的说这种情况是理想情况。

4.避免重复求解

这个最简单，建个数组就行。

#include<iostream>
#include<cstring>
using namespace std;
string A,B;
char s1[2005],s2[2005];//s1=A , s2=B
int edit[2005][2005];
int dp(int i,int j){ 
    if(edit[i][j]!=-1) return edit[i][j]; 
    if(i==0) return edit[i][j]=j;
    if(j==0) return edit[i][j]=i;
    int bonus=1;
    if(s1[i]==s2[j]) bonus=0;  
    return edit[i][j]=min(min(dp(i-1,j)+1,dp(i,j-1)+1),dp(i-1,j-1)+bonus);
}
int main(){
    cin>>A>>B;
    memset(edit,-1,sizeof(edit));
    int len1=A.length(),len2=B.length();
    for(int i=1;i<=len1;i++ ) s1[i]=A[i-1];//将字符串转成cstring 
    for(int i=1;i<=len2;i++) s2[i]=B[i-1];
    dp(len1,len2);
    cout<<edit[len1][len2];
    return 0;
}

假设用f[i][j]表示将串a[1…i]转换为串b[1…j]所需的最少操作次数（最短距离）

首先是边界：

①i==0时，即a为空，那么对应的f[0][j]的值就为j：增加j个字符，使a转化为b

②j==0时，即b为空，那么对应的f[i][0]的值就为i：减少i个字符，使a转化为b

然后考虑一般情况（这里是DP思想）：我们要得到将a[1..i]经过最少次数的操作就转化为b[1..j]，那么我们就必须在此之前以最少次数（假设为k次）的操作,使现在的a和b只需再做一次操作或者不做操作就可以使a[1..i]转化到b[1..j]。而“之前”有三种情况：

①将a[1…i]转化为b[1…j-1]

②将a[1..i-1]转化为b[1..j]

③将a[1…i-1]转化为b[1…j-1]

第①种情况，只需要在最后将a[j]加上b[1..i]就可以了，总共就需要k+1次操作。

第②种情况，只需要在最后将a[i]删除，总共需要k+1个操作。

第③种情况，只需要在最后将a[i]替换为b[j]，总共需要k+1个操作。但如果a[i]刚好等于b[j]，就不用再替换了，那就只需要k个操作。

为了得到最小值，将以上三种情况的最小值作为f[i][j]的值（我前面不是说了f[i][j]表示串a[1…i]转换为串b[1…j]所需的最少操作次数嘛）,最后答案在f[n][m]中。

实现（只描述算法部分）

初始化。边界情况，用循环嵌套或两个独立的循环都可以做到。

2.循环嵌套遍历f数组，先处理a[i]==b[j]的情况，如不满足，再从三种情况中选择最小的，作为f[i][j]的值。三种情况中，①如果在k个操作里将a[1…i-1]转换为b[1..j]，那就可以将a[i]删除，共需k+1个操作，所以是f[i-1][j]+1;②如果在k个操作里将a[1…i]转换为b[1…j-1] ，那就可以加上b[j]，共需k+1个操作；③如果我们可以在k个操作里将a[1…i-1]转换为b[1…j-1]，那就可以将a[i]转换为b[j]，也是共需k+1个操作。（前面已经处理过了a[i]==b[j]的情况）

3.最后的答案是f[][]最后一个元素的值。

#include<cstdio>
    #include<iostream>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    int f[3005][3005],lena,lenb;
    char a[3005],b[3005];
    void dp()
    {
        for(int i=1;i<=lena;i++)
            f[i][0]=i;
        for(int i=1;i<=lenb;i++)
            f[0][i]=i;
        for(int i=1;i<=lena;i++)
            for(int j=1;j<=lenb;j++)
            {
                if(a[i-1]==b[j-1])
                {
                    f[i][j]=f[i-1][j-1];
                    continue;
                }
                f[i][j]=min(min(f[i-1][j],f[i][j-1]),f[i-1][j-1])+1;
            }
    }
    int main()
    {
        scanf("%s %s",a,b);
        lena=strlen(a);
        lenb=strlen(b);
        dp();
        printf("%d\n",f[lena][lenb]);
    }

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
char a[4005],b[4005];
int lena,lenb,f[4005][4005],k;//f(i,j)表示将A串前i个字符改为B串前j个字符需要的步数
int main() {
    cin>>a>>b;
    lena=strlen(a);lenb=strlen(b);
    for(int i=lena;i>=1;i--) a[i]=a[i-1];
    for(int i=lenb;i>=1;i--) b[i]=b[i-1];//初始化
    for(int i=0;i<=lena;i++) f[i][0]=i;
    for(int i=0;i<=lenb;i++) f[0][i]=i;//边界状态 因为将A串无字符变到B串i个字符时需要加i个字符 B串无字符时同理
    for(int i=1;i<=lena;i++){
        for(int j=1;j<=lenb;j++){
            k=1;//在后面会用到 方便‘改’的操作
            if(a[i]==b[j]) k=0;
            f[i][j]=min(min(f[i-1][j]+1,f[i][j-1]+1),f[i-1][j-1]+k);//若当前A、B串指向字符相等则不进行‘改’的操作
        }
    }
    printf("%d",f[lena][lenb]);//就是将A串前lena个数变为B串前lenb个数
    return 0;
}