【AcWing】线性DP、区间DP、计数类DP

一、线性DP

数字三角形

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

     7
   3   8
 8   1   0
2   7   4   4
4   5   2   6   5

输入格式

第一行包含整数 n，表示数字三角形的层数。

接下来 n 行，每行包含若干整数，其中第 i 行表示数字三角形第 ii 层包含的整数。

输出格式

输出一个整数，表示最大的路径数字和。

数据范围

1≤n≤500
−10000≤三角形中的整数≤10000

输入样例：

5
7
3 8
8 1 0 
2 7 4 4
4 5 2 6 5

输出样例：

30

1. 状态表示：f[i,j]
   1. 集合：所有从起点，走到(i,j)的路径
   2. 属性：集合中，所有路径上的数字之和的最大值
2. 状态计算：集合的划分
   
   因此f[i,j] = 左右两种情况取Max

注意，当涉及到i-1这种下标，一般在初始化时下标从1开始，来避免越界

dp时间复杂度计算=状态数量*转移计算量

#include<iostream>
#include<algorithm>
using namespace std;

const int N=510,INF=1e9;

int n;
int a[N][N];
int f[N][N];//存储的是走到(i,j)这个点，路径上的所有数字之和

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            scanf("%d",&a[i][j]);
   
    //初始化
    //在边界点也会计算上左和上右，但这两个点在边界时不存在，但需要初始化为负无穷
    //故j需要多初始化0和i+1
    for(int i=0;i<=n;i++)
        for(int j=0;j<=i+1;j++)
            f[i][j]=-INF;
            
    f[1][1]=a[1][1];
    for(int i=2;i<=n;i++)
        for(int j=1;j<=i;j++)
            f[i][j]=max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
            
    int res=-INF;
    for(int i=1;i<=n;i++) res=max(res,f[n][i]);//遍历一下最后一层，找出最大的那个
    
    printf("%d\n",res);
    return 0;
}

也可以用倒叙dp，会更简单些，不需要考虑边界问题

#include<iostream>
#include<algorithm>
using namespace std;

const int N=510;
int f[N][N];
int n;

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            cin>>f[i][j];
        }
    }

    for(int i=n;i>=1;i--){
        for(int j=i;j>=1;j--){
            f[i][j]=max(f[i+1][j],f[i+1][j+1])+f[i][j];
        }
    }
    cout<<f[1][1]<<endl;
}

最长上升子序列I

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 N。

第二行包含 N 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1 ≤ N ≤ 1000，
−10^ 9≤ 数列中的数 ≤ 10^9

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

1. 状态表示：f[i]:以i结尾的最长上升子序列的长度

   1. 集合：所有以第i个数结尾的上升子序列
   2. 属性：集合里每一个上升子序列的长度的Max

2. 状态计算：集合的划分

   以前一个数字是第几个来分类
   
   状态转移方程：f[i]=max(f[j]+1),j=0,1,2,...,i-1

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;

int n;
int a[N],f[N];

int main(){
    cin>>n;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    
    for(int i=1;i<=n;i++){
        f[i]=1;//只有a[i]一个数
        for(int j=1;j<i;j++)//枚举上一个数
            if(a[j]<a[i])//满足上升子序列的条件的
                f[i]=max(f[i],f[j]+1);//则更新一次f[i]
    }
    
    //经过以上循环，每个位置的最长上升子序列的长度都已经存到对应的f[i]中
    //但是仍未知最大的是哪一个
    int res=0;
    for(int i=1;i<=n;i++) res=max(res,f[i]);//枚举所有终点，以求得最大值
    
    cout<<res<<endl;
    return 0;
}

最长上升子序列II

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 N。

第二行包含 NN 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N≤100000，
−109≤数列中的数≤109

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

对于长度为i的上升子序列，只存储结尾值最小的那个，用q[i]来存储最小的结尾值

a[i]接到最大的小于a[i]的数后面，可用二分来寻找

例如，q[4]<a[i],q[5]>=a[i]，q[4]是小于a[i]的最大的数，因此将a[i]接到q[4]后面去，那么这个序列变成了5个数，则q[5]更新为a[i]

#include<iostream>
#include<algorithm>
using namespace std;

const int N=100010;

int n;
int a[N];
int q[N];

int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    
    int len=0;//存储最大长度，也就是q[]中的元素个数
    q[0]=-2e9;//边界处理
    for(int i=0;i<n;i++){
        int l=0,r=len;
        while(l<r){//最终l和r为小于a[i]的最大的数在q中的下标
            int mid=(l+r+1)/2;
            if(q[mid]<a[i]) l=mid;//这里是小于不含等于
            else r=mid-1;
        }
        len=max(len,r+1);//把a[i]接上去之后更新长度
        q[r+1]=a[i];//更新下一个q
    }
    cout<<len<<endl;
    return 0;
}

最长公共子序列

给定两个长度分别为 N 和 M 的字符串 A 和 B，求既是 A 的子序列又是 B 的子序列的字符串长度最长是多少。

输入格式

第一行包含两个整数 N 和 M。

第二行包含一个长度为 N 的字符串，表示字符串 A。

第三行包含一个长度为 M 的字符串，表示字符串 B。

字符串均由小写字母构成。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N,M≤1000

输入样例：

4 5
acbd
abedc

输出样例：

3

1. 状态表示：f[i,j](两个序列，一般两维)

   1. 集合：所有在第一个序列的前i个字母中出现，并且在第二个序列的前j个字母中出现的子序列
   2. 属性：Max

2. 状态计算：

   以a[i],b[j]是否在子序列中来划分，共四种情况
   
   此题分成的四个部分有重叠，但是求最大/最小值可以有重叠，求数量才会要求无。

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;

int n,m;
char a[N],b[N];
int f[N][N];

int main(){
    scanf("%d%d",&n,&m);
    scanf("%s%s",a+1,b+1);//用到了i-1和j-1，所以下标从1开始，故要往后一位
    
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            f[i][j]=max(f[i-1][j],f[i][j-1]);//先求中间两种情况的最大值
            if(a[i]==b[j]) f[i][j]=max(f[i][j],f[i-1][j-1]+1);//如果满足第i个和第j个可以同时包含or不包含
        }
    }
    
    printf("%d\n",f[n][m]);
}

最短编辑距离

给定两个字符串 A 和 B，现在要将 A 经过若干操作变为 B，可进行的操作有：

1. 删除–将字符串 A 中的某个字符删除。
2. 插入–在字符串 A 的某个位置插入某个字符。
3. 替换–将字符串 A 中的某个字符替换为另一个字符。

现在请你求出，将 A 变为 B 至少需要进行多少次操作。

输入格式

第一行包含整数 n，表示字符串 A 的长度。

第二行包含一个长度为 n 的字符串 A。

第三行包含整数 m，表示字符串 B 的长度。

第四行包含一个长度为 m 的字符串 B。

字符串中均只包含大小写字母。

输出格式

输出一个整数，表示最少操作次数。

数据范围

1≤n,m≤1000

输入样例：

10 
AGTCTGACGC
11 
AGTAAGTAGGC

输出样例：

4

1. 状态表示：f[i][j]

   1. 集合：所有将a[1~i]变成b[1~j]的操作方式中的操作次数
   2. 属性：Min

2. 状态计算

   分为三种情况：

   • 删a[i]后匹配，即a[1~i-1]和b[1~i]匹配
   • 在a[i]后增加后匹配，即a[1~i]和b[1~i]匹配
   • 改变a[i](即把a[i]变成b[j])后匹配，即a[1~i-1]和b[1~j-1]匹配
     
     状态转移方程：f[i][j]=min(f[i-1][j]+1.f[i][j-1]+1,f[i-1][j-1]+1)

​ 时间复杂度：$O(n^2)$

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010;

int n,m;
char a[N],b[N];
int f[N][N];

int main(){
    cin>>n>>a+1>>m>>b+1;//让字符串下标从1开始
    
    //初始化边界
    for(int i=0;i<=m;i++) f[0][i]=i;//在a[]后增加i次
    for(int i=0;i<=n;i++) f[i][0]=i;//删除a[]i次
      
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
            if(a[i]==b[j]) f[i][j]=min(f[i][j],f[i-1][j-1]);
            else f[i][j]=min(f[i][j],f[i-1][j-1]+1);
        }
        
    printf("%d\n",f[n][m]);//把a的前n个字母变成b的前m个字母
    
    return 0;
}

编辑距离

给定 n 个长度不超过 10 的字符串以及 m 次询问，每次询问给出一个字符串和一个操作次数上限。

对于每次询问，请你求出给定的 n 个字符串中有多少个字符串可以在上限操作次数内经过操作变成询问给出的字符串。

每个对字符串进行的单个字符的插入、删除或替换算作一次操作。

输入格式

第一行包含两个整数 n 和 m。

接下来 n 行，每行包含一个字符串，表示给定的字符串。

再接下来 m 行，每行包含一个字符串和一个整数，表示一次询问。

字符串中只包含小写字母，且长度均不超过 10。

输出格式

输出共 m 行，每行输出一个整数作为结果，表示一次询问中满足条件的字符串个数。

数据范围

1≤n,m≤1000,

输入样例：

3 2
abc
acd
bcd
ab 1
acbd 2

输出样例：

1
3

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=15,M=1010;

int n,m;
int f[N][N];
char str[M][N];

int edit_distance(char a[],char b[]){
    int la=strlen(a+1),lb=strlen(b+1);
    
    for(int i=0;i<=lb;i++) f[0][i]=i;
    for(int i=0;i<=la;i++) f[i][0]=i;
    
    for(int i=1;i<=la;i++)
        for(int j=1;j<=lb;j++){
            f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
            f[i][j]=min(f[i][j],f[i-1][j-1]+(a[i]!=b[j]));
        }
        
    return f[la][lb];
}

int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++) scanf("%s",str[i]+1);
    
    while(m--){
        char s[N];
        int limit;
        cin>>s+1>>limit;
        
        int res=0;
        for(int i=0;i<n;i++)
            if(edit_distance(str[i],s)<=limit)
                res++;
      
        printf("%d\n",res);
    }  
    return 0;
}

二、区间DP

设有 N 堆石子排成一排，其编号为 1，2，3，…，N。

每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

例如有 44 堆石子分别为 1 3 5 2， 我们可以先合并 1、2 堆，代价为 4，得到 4 5 2， 又合并 1，2堆，代价为 9，得到 9 2 ，再合并得到 11，总代价为 4+9+11=24；

如果第二步是先合并 2，3 堆，则代价为 7，得到 4 7，最后一次合并代价为 11，总代价为 4+7+11=22。

问题是：找出一种合理的方法，使总的代价最小，输出最小代价。

输入格式

第一行一个数 N 表示石子的堆数 N。

第二行 N 个数，表示每堆石子的质量(均不超过 1000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤N≤300

输入样例：

4
1 3 5 2

输出样例：

22

1. 状态表示：f[i,j] 第i堆石子到第j堆石子这个区间

   1. 集合：所有将第i堆石子到第j堆石子合并成一堆石子的合并方式
   2. 属性：所有合并方式里代价的Min

2. 状态计算

   最后一次合并，必为左边一半和右边一半的合并，因此以最后一次合并的分界线位置来分类

   如图数字表示最后一次合并时，左边石子的个数
   
   设最后一步的两个区间为[i,k],[k+1,j]

​ 先把最后一步合并代价去掉，则除了最后一步的最小代价为：f[i,k]+f[k+1,j]

​ 则最终的代价为：f[i,k]+f[k+1,j]+s[j]-s[j-1],即之前的最小代价+合并剩下两堆所需的代价（由前缀和算出）

​ 状态转移方程：

​ 当i=j时，f[i][j]=0（合并一堆石子代价为0）

​ 当i<j时，f[i,j]=min(f[i,k]+f[k+1,j]+s[j]-s[i-1]),k=i~j-1

​ 时间复杂度：$O(n^3)$

区间dp常用模板

第一维通常是枚举区间长度，并且一般len=1时用来初始化，枚举从len=2开始，第二维枚举起点i（右端点j自动获得，j=i+len-1）

for (int len = 1; len <= n; len++) {         // 区间长度
    for (int i = 1; i + len - 1 <= n; i++) { // 枚举起点
        int j = i + len - 1;                 // 区间终点
        if (len == 1) {
            dp[i][j] = 初始值
            continue;
        }

        for (int k = i; k < j; k++) {        // 枚举分割点，构造状态转移方程
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);
        }
    }
}

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=310;

int n;
int s[N];
int f[N][N];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&s[i]);
    
    for(int i=1;i<=n;i++) s[i]+=s[i-1];//计算前缀和
    
    for(int len=2;len<=n;len++)//枚举区间长度,区间长度为1，合并不需要代价，故从2开始，且全局变量f[i][j]均为0，故len=1不需单独初始化
        for(int i=1;i+len-1<=n;i++)//枚举起点
        {
            int l=i,r=i+len-1;//左端点和右端点
            f[l][r]=1e8;//每次算之前要初始化，因为初始为0，而此题求的又是min，先赋一个较大的值
            for(int k=l;k<r;k++)//枚举分界点
                f[l][r]=min(f[l][r],f[l][k]+f[k+1][r]+s[r]-s[l-1]);
        }
        
        cout<<f[1][n]<<endl;
        return 0;
}

补充：记忆化搜索

int dp(int i, int j) {
    if (i == j) return 0; // 判断边界
    int &v = f[i][j];

    if (v != -1) return v;

    v = 1e8;
    for (int k = i; k <= j - 1; k ++)
        v = min(v, dp(i, k) + dp(k + 1, j) + s[j] - s[i - 1]);

    return v;
}

三、计数类DP

整数划分

一个正整数 n 可以表示成若干个正整数之和，形如：n=n1+n2+…+nk，其中 n1≥n2≥…≥nk,k≥1。

我们将这样的一种表示称为正整数 n 的一种划分。

现在给定一个正整数 n，请你求出 n 共有多少种不同的划分方法。

输入格式

共一行，包含一个整数 n。

输出格式

共一行，包含一个整数，表示总划分数量。

由于答案可能很大，输出结果请对 109+7 取模。

数据范围

1≤n≤1000

输入样例:

5

输出样例：

7

思路一

看作完全背包问题，将这个数看作一个容量为n的背包，物体的体积分别为1,2,3…，每种物体为无限个

1. 状态表示：f[i][j]
   1. 集合：1~i中选，体积为j的选法的数量
   2. 属性：数量
2. 状态计算：按照第i个物品选择了多少来划分
   
   f[i][j]=f[i-1][j]+f[i-1][j-i]+f[i-1][j-i*2]+...+f[i-1][j-i*s]

f[i][j-1]= f[i-1][j-i]+f[i-1][j-i*2]+...+f[i-1][j-i*s]

由上两式可得：f[i][j]=f[i-1][j]+f[i][j-i]

优化：f[j]=f[j]+f[j-i](体积从小到大循环即可)

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010,mod=1e9+7;

int n;
int f[N];

int main(){
    cin>>n;
    f[0]=1;//从1开始循环，又涉及到了j-i，故初始化f[0]
    for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++)
            f[j]=(f[j]+f[j-i])%mod;
            
    cout<<f[n]<<endl;
    return 0;
}

思路二

1. 状态表示：f[i][j]
   1. 集合：所有总和是i，并且恰好表示成j个数的和的方案
   2. 属性：数量
2. 状态计算
   
   把最小值是1的方案中去掉一个1，则可以表示成f[i-1,j-1]

而对于最小值大于1的方案，可以把每一个数都减去1，则可以表示成f[i-j,j]

状态转移方程：f[i,j]=f[i-1,j-1]+f[i-j,j]

所求：ans=f[n,1]+f[n,2]+...+f[n,n]

#include<iostream>
#include<algorithm>
using namespace std;

const int N=1010,mod=1e9+7;

int n;
int f[N][N];

int main(){
    cin>>n;
    f[0][0]=1;//定义边界
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            f[i][j]=(f[i-1][j-1]+f[i-j][j])%mod;
            
    int res=0;
    for(int i=1;i<=n;i++) res=(res+f[n][i])%mod;
    
    cout<<res<<endl;
    
    return 0;
}