常见动态规划类型（线性DP、区间DP、计数DP、数位DP）

chp的博客

已于 2022-10-19 18:18:29 修改

阅读量1.6k

点赞数

分类专栏：动态规划文章标签：动态规划算法 c++

于 2022-10-07 22:13:55 首次发布

本文链接：https://blog.csdn.net/qq_43851311/article/details/127200266

版权

动态规划专栏收录该内容

19 篇文章 1 订阅

订阅专栏

文章目录

线性DP
区间DP
计数类DP
数位统计DP

递归求解子问题—动态规划

解决动态规划问题一般有两种方法：状态转移表法和状态转移方程法

1.最优子结构：
问题的最优解包含子问题的最优解，子问题的最优解可以推导出原问题的最优解

2.无后效性：
有两层含义，第一层含义是，在推导后面阶段状态的时候，我们只关心前面阶段的状态值，不关心这个状态是怎么一步步推导出来的。第二层含义是，某阶段状态一旦确定，就不受之后阶段的决策影响。无后效性是一个非常“宽松”的要求。只要满足动态规划问题模型，其实基本上都会满足无后效性。

3.不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态

线性DP

最长回文字序列

题目链接：516. 最长回文子序列 - 力扣（LeetCode）

状态表示：

f[i][j],表示从i~j中s的最长回文子序列

s[i]==s[j]时，f[i][j]=f[i+1][j-1]+2;
s[i]!=s[j]时，f[i][j]=max(f[i+1][j],f[i][j-1])

代码如下:

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int f[1010][1010];
        for(int i=1;i<=s.size();i++) f[i][i]=1;
        for(int i=s.size();i>=1;i--)
            for(int j=i+1;j<=s.size();j++)
                if(s[i-1]==s[j-1]) f[i][j]=f[i+1][j-1]+2;
                else f[i][j]=max(f[i+1][j],f[i][j-1]);
        return f[1][s.size()];

    }
};

最长公共子序列


f[i][j]表示，s1[0~i]与s2[0~j]的最长公共子序列
    
s1[i]==s2[j]时，f[i][j]=f[i-1][j-1]+1;
else f[i][j]=max(f[i-1][j],f[i][j-1])

相关例题与代码：最长公共子序列_Chen的博客的博客-CSDN博客

最短编辑距离

题目链接：902. 最短编辑距离 - AcWing题库

状态表示:
f[i][j]表示所有将A[1~i]变成B[1-j]的操作方式最小步骤数

状态转移:
考虑最后一步的情况:
(1)将A[i]删掉(A[i]删掉,说明此时A[1~i-1]和B的[1-j]已经匹配了) f[i][j]=f[i-1][j]+1;
(2)增加A[i](此时A[1~i]和B的[1-j-1]已经匹配，而且添加的A[i]==B[j]) f[i][j]=f[i][j-1]+1;
(3)修改A[i](将A[i]变成B[j]) 
	A[i]==B[j] f[i][j]=f[i-1][j-1]
	A[i]!=B[j] f[i][j]=f[i-1][j-1]+1
f[i][j]能从上述三个方案转移而来，对上述方案取min即可

初始化:
1.f[0][i]如果a初始长度就是0，那么只能用插入操作让它变成b
  f[i][0]同样地，如果b的长度是0，那么a只能用删除操作让它变成b
2.f[i][j] = INF //虽说这里没有用到，但是把考虑到的边界都写上还是保险

代码如下：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N=1010;
const int inf=0x3f3f3f3f;
int n,m;
char s1[N],s2[N];
int f[N][N];
int main(){
    cin>>n>>s1+1>>m>>s2+1;
    //初始化边界情况
    for(int i=0;i<=m;i++) f[0][i]=i;//A的前0个字母想要匹配B的前i个字母，只能添加
    for(int i=0;i<=n;i++) f[i][0]=i;//A的前i个字母想要匹配B的前0个字母，只能删除
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            f[i][j]=inf;
            f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);//首先比较插入和删除
            if(s1[i]==s2[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);
        }
    cout<<f[n][m];
    return 0;
}

编辑距离

题目链接：899. 编辑距离 - AcWing题库

这道题与上一题的思路相同，可以用作练习。

代码如下：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<string>
using namespace std;

const int N=1010;
const int inf=0x3f3f3f3f;

int main(){
    int n,m;
    string s;
    vector<string> v;
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>s;
        v.push_back(s);
    }
    while(m--){
        int t,res=0;
        int f[15][15];
        cin>>s>>t;
        for(int k=0;k<v.size();k++){
            memset(f,0,sizeof f);
            for(int i=1;i<=s.size();i++) f[0][i]=i;
            for(int i=1;i<=v[k].size();i++) f[i][0]=i;
            
            for(int i=1;i<=v[k].size();i++)
                for(int j=1;j<=s.size();j++){
                    f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
                    if(v[k][i-1]==s[j-1]) 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);
                }
            if(f[v[k].size()][s.size()]<=t) res++;
        }
        cout<<res<<endl;
    }
    return 0;
}

总结

线性DP一般考虑子问题的最后一步，确定状态表示和状态转移即可

区间DP

区间DP，就是在区间上求解最优解问题
将大区间划分为小区间，然后用小区间的最优解合并得到大区间的最优解

经典例题: 石子合并 - AcWing题库

考虑最后一次合并
肯定是前面k堆和后面的n-k堆合并到一起，代价为石头总数量n

那么子问题就可以分为 求 1-k堆石子合成的最小值 ， k+1到n堆石子合成的最小值

定义状态:
f[i][j]表示考虑把第i堆到第j堆合起来的最小花费

考虑转移:
f[i][j]=min(f[i][k])+min(f[k+1][j])+sum[i][j])，k从i枚举到j-1
sum[i][j]可由前缀和公式得来

按照区间长度从小到大来枚举

代码如下:

 #include<cstdio>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 const int N=310;
 const int inf=0x3f3f3f3f;
 
 int f[N][N];
 int s[N];
 int main(){
     int n;
     cin>>n;
     for(int i=1;i<=n;i++){
         scanf("%d",&s[i]);
         s[i]+=s[i-1];
     }
     for(int len=2;len<=n;len++)
        for(int i=1;i+len-1<=n;i++){
            int l=i,r=i+len-1;
            f[l][r]=inf;
            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];
    return 0;
}

计数类DP

题目链接:900. 整数划分 - AcWing题库

DP求方案数
样例:
5
4 1
3+2
2+2+1
2+1+1+1
3+1+1
1+1+1+1+1
一共7种

解法一:考虑转化为背包问题

背包容量为n，物品体积为1~n，每件物品无数个，求恰好装满背包的方案数（完全背包问题）

状态表示：
f[i][j]表示从1-i中选择，体积正好为j的方案数

状态转移：
考虑第i个物品
不选：f[i][j]=f[i-1][j]
选一个：f[i][j]=f[i-1][j-i]
选两个:f[i][j]=f[i][j-i*2]
.
.
.
选n个：f[i][j]=f[i][j-i*n]
f[i][j]=f[i-1][j]+f[i-1][j-i]+f[i-1][j-i*2]+....+f[i-1][j-i*n]
f[i][j-i]=        f[i-1][j-i]+f[i-1][j-i*2]+....+f[i-1][j-i*n]
可得：
f[i][j]=f[i-1][j]+f[i][j-i]
优化空间：
f[j]=f[j]+f[j-i]


解法二：
状态表示：
所有总和为i，并且恰好表示成j个数的和的方案

状态转移：
f[i][j]可分为两大类
(1)方案中最小值是1  
	f[i-1][j-1]
(2)方案中最小值大于1
	f[i-j][j]
f[i][j]=f[i-1][j-1]+f[i-j][j]
res=f[n,1]+f[n][2]+....+f[n][n]

解法三：
分治思路(容易理解)
f[i][j]表示当前数为i时，分出数最大值小于等于j，所具有的方案数
比如：
5由下面5种组成
5
4 1
3+2
3+1+1
2+2+1
2+1+1+1
1+1+1+1+1
f[5][1]=1
f[5][2]=3
f[5][3]=5
f[5][4]=6
f[5][5]=7

考虑分治成子问题：
（1）显然i<j时,可分的最大数为i到达不了j，所以
f[i][j]=f[i][i]
(2)i=j
f[i][j]=f[i][j-1]+1
加上的的这一次为n本身这一次
(3)i>j时
f[i][j]=f[i][j-1]+f[i-j][j]
f[i][j-1]表示可分的数最大值为j-1的方案数,再加上最大值为j的方案即可(注意：至少有一个j,所以表示为f[i-j][j])

代码如下:

#解法一：转化为背包问题求方案数
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1010,M=1e9+7;

int f[N];

int main(){
    int n;
    cin>>n;
    f[0]=1;//初始化，什么都不选时为1个方案
    for(int i=1;i<=n;i++) 
        for(int j=i;j<=n;j++)
            f[j]=(f[j]+f[j-i])%M;
    cout<<f[n]; 
    return 0;
}

#解法二
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1010,M=1e9+7;

int f[N][N];

int main(){
    int n,res=0;
    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])%M;
    for(int i=1;i<=n;i++) res=(res+f[n][i])%M;
    cout<<res;
    return 0;
}
#解法三
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1010,M=1e9+7;

int f[N][N];
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(i<j) f[i][j]=f[i][i];
            else if(i==j) f[i][j]=(f[i][j-1]+1)%M;
            else if(i>j) f[i][j]=(f[i][j-1]+f[i-j][j])%M;
    cout<<f[n][n];
            
    
    return 0;
}

数位统计DP

题目链接：338. 计数问题 - AcWing题库

a,b的数据范围较大，暴力枚举方法不可取

count(n,x)函数表示，1~n中x出现的次数
a~b中x出现的次数=count(b,x)-count(a-1,x)

分情况讨论：
例如，求1~n中,x=1出现的次数
n=abcdefg七位数
分别求出1在每一位上出现的次数
例如求在第四位上出现1的数，即1<=XXX1yyy<=abcdefg
(1)xxx=000~abc-1,yyy=000~999,选法为abc*1000
(2)xxx=abc
	(2.1) d<x=1时，abc1yyy>abc0efg , 0种
	(2.2) d=x=1时，yyy=000~efg ， efg+1种
	(2.3) d>x=1时，yyy=000~999，1000种
x=1出现在第四位上的次数等于上述情况之和

代码如下：

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

int get(vector<int>num,int l,int r){
    int res=0;
    for(int i=l;i>=r;i--) res=res*10+num[i];
    return res;
}

int power10(int x){
    int res=1;
    while(x--) res*=10;
    return res;
}

int count(int n,int x){
    if(!n) return 0;
    vector<int> num;
    while(n){
        num.push_back(n%10);
        n/=10;
    }
    n=num.size();
    
    int res=0;
    for(int i=n-1-!x;i>=0;i--){
        if(i<n-1){
            res+=get(num,n-1,i+1)*power10(i);
            if(!x) res-=power10(i);
        }
        if(num[i]==x) res+=get(num,i-1,0)+1;
        else if(num[i]>x) res+=power10(i);            
    }
    return res;
}

int main() {
    int a,b;
    while(scanf("%d%d",&a,&b)&&a) {
        if(a>b) swap(a,b);
        for(int i=0; i<=9; i++) cout<<count(b,i)-count(a-1,i)<<" ";
        cout<<endl;
    }
    return 0;
}