各类动态规划（持续更新）

最新推荐文章于 2024-06-01 17:36:21 发布

置顶 ddgo

最新推荐文章于 2024-06-01 17:36:21 发布

阅读量859

点赞数

分类专栏： 0开始的动态规划

本文链接：https://blog.youkuaiyun.com/qq_45604735/article/details/115184034

版权

0开始的动态规划专栏收录该内容

38 篇文章

订阅专栏

update: 2021/6/25

动态规划

线性DP

MaxSumPlusPlus

解释

状态表示 dp（i，j）表示前j个分成i组且以j结尾，获得的最大值。

目标状态 max（dp（m，i），…） $\le n , i\ge m$

初始化 全为0

转移方程 dp（i，j） = max（dp（i，j - 1）+ a（j），dp（i - 1，k） + a（j））其中 $k\ge i-1,k\le j-1$

二维写出来基本是这样，无论是时间还是空间，都很差。

signed main(){
    int m,n; 
    while(cin>>m>>n){
    	memset(dp,0,sizeof(dp));
    	for(int i=1;i<=n;i++) cin>>a[i];
    	for(int i=1;i<=m;i++){
    		for(int j=i;j<=n;j++){
    			int maxx = -1e18;
    			for(int k=i-1;k<j;k++) maxx = max(maxx,dp[i-1][k]);
    			if(j == i) dp[i][j] = maxx + a[j];
    			else dp[i][j] = max(dp[i][j-1],maxx) + a[j];
			}
		}
		int ans = -1e18;
		for(int i=m;i<=n;i++) ans = max(ans,dp[m][i]);
		cout<<ans<<endl;
	}
	return 0;
}

时间优化

对于这个

for(int k=i-1;k<j;k++) maxx = max(maxx,dp[i-1][k]);

因为j是递增的，每次dp（i-1，k）的前半部分都会重复计算。所以可以每次存一次就行。

用f（j - 1）表示dp（i - 1，j - 1）中的最大值。再将dp（i，j）降维。

取最后一次处理的最大值，即为答案。

代码

#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 10;

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

signed main(){
    IOS
    int m,n; 
    while(cin>>m>>n){
        memset(dp,0,sizeof(dp));
        memset(f,0,sizeof(f));
        for(int i=1;i<=n;i++) cin>>a[i];
        int maxx;
        for(int i=1;i<=m;i++){
            maxx = -1e18;
            for(int j=i;j<=n;j++){
                dp[j] = max(dp[j-1],f[j-1]) + a[j];
                f[j-1] = maxx;
                maxx = max(maxx,dp[j]);
            }
        }
        cout<<maxx<<endl;
    }
    return 0;
}

DAG上的DP

MonkeyandBanana

解释

每一个块可以有三种放置方式，只要a的底面两条边严格小于b，那么就可以将它们连接一条有向边。之后跑一边拓扑序，就可以得到最大值。建图稍微麻烦，用（i-1）+ k （k = 0，1，2）来分配一个块的一个状态id。

代码

#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#include<bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;

int mp[N][N],d[N],dp[N],w[N];
struct Node{
	int x,y,z;
}node[N];

int s[3][3] = {{1,1,0},{1,0,1},{0,1,1}};
int ans,n,kase=1;

void top_sort(){
	n = (n-1)*3 + 2;
	queue<int> qe;
	for(int i=0;i<=n;i++) if(!d[i]) dp[i] = w[i],qe.push(i);
	while(!qe.empty()){
		int u = qe.front();qe.pop();
		for(int i=0;i<=n;i++){
			if(!mp[u][i]) continue;
			dp[i] = max(dp[i],dp[u] + w[i]);
			ans = max(dp[i],ans);
			if(--d[i] == 0) qe.push(i);
		}
	}
}

signed main(){
	IOS
    while(cin>>n && n){
    	ans = 0;
    	memset(mp,0,sizeof(mp));
    	memset(dp,0,sizeof(dp));
    	for(int i=1;i<=n;i++) cin>>node[i].x>>node[i].y>>node[i].z;
    	for(int i=1;i<=n;i++)
    		for(int j=1;j<=n;j++)
    			for(int p1=0;p1<3;p1++){
    				int x1,y1,z1,st = (i-1)*3+p1;
					if(p1 == 0) x1 = node[i].x,y1 = node[i].y,z1 = node[i].z;
					else if(p1 == 1) x1 = node[i].x,y1 = node[i].z,z1 = node[i].y;
					else x1 = node[i].y,y1 = node[i].z,z1 = node[i].x;
					w[st] = z1;
    				for(int p2=0;p2<3;p2++){
    					int x2,y2,z2,ed = (j-1)*3+p2;;
						if(p2 == 0) x2 = node[j].x,y2 = node[j].y,z2 = node[j].z;
						else if(p2 == 1) x2 = node[j].x,y2 = node[j].z,z2 = node[j].y;
						else x2 = node[j].y,y2 = node[j].z,z2 = node[j].x;
						w[ed] = z2;
    					if((x1 > x2 && y1 > y2) || (x1 > y2 && y1 > x2)) mp[st][ed] = 1,d[ed] ++;
					}
				}
		top_sort();
		cout<<"Case "<<kase++<<": maximum height = "<<ans<<endl;
	}
	return 0;
}

区间DP

石子合并

解释

状态表示 dp(i,j)表示合并 i ~ j 所花费的最小价值

目标状态 dp(1,n)

初始化 dp(i,i) 为0

转移方程 dp(i,j) dp(i,j) = min(dp(i,j),dp(i,k)+dp(k+1,j)) dp(i,j) += sum(i,j) 表示当前状态可以以k为分界点进行两堆的合并。

而dp(i,k) 也可以由更小的区间进行合并.

模板

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;

int dp[N][N],sum[N];

int main(){
    int n; cin>>n;
    memset(dp,0x3f,sizeof(dp));
    for(int i=1;i<=n;i++){
        int a; cin>>a;
        dp[i][i] = 0;
        sum[i] = sum[i-1] + a;
    }
    for(int len=2;len<=n;len++)
        for(int l=1;l<=n-len+1;l++){
            int r = l + len - 1;
            for(int k=l;k<r;k++) dp[l][r] = min(dp[l][k]+dp[k+1][r],dp[l][r]);
            dp[l][r] += sum[r] - sum[l-1];
        }
    cout<<dp[1][n]<<endl;
    return 0;
}

多边形

解释

环形拆分成链，变成两倍长度。然后与石子合并一样，可以由哪个点的两边合并。因为有乘法，所以要维护最小值，因为最小值乘最小值可以变成最大值。

状态表示 dp(i,j,0) 合并(i,j)区间所得到的最大值，dp(i,j,1) 合并(i,j) 区间得到的最小值.

目标状态 max{ dp(i,i+n-1,0) } 以i为起点的长度为n。

状态转移 当以k为分界点时

k+1表示加法时

dp(l,r,0) = max( dp ( l , r , 0 ) , dp ( l , k , 0 ) + dp ( k + 1 , r , 0 )

dp(l,r,1) = min( dp ( l , r , 1 ) , dp ( l , k , 1 ) + dp( k + 1 , r , 1 ) )

k+1表示乘法时

p,q 为 {0,1}

dp(l,r,0) = max( dp ( l , r , 0 ) , dp ( l , k , p ) * dp ( k + 1 , r , p )

dp(l,r,1) = min( dp ( l , r , 1 ) , dp ( l , k , q ) * dp( k + 1 , r , q ) )

模板

#include<bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;

int dp[N][N][2];
int w[N];
char op[N];

int main(){
    int n; cin>>n;
    for(int i=1;i<=n;i++){
        cin>>op[i]>>w[i];
        op[n+i] = op[i];
        dp[i][i][0] = dp[i][i][1] = w[i];
        dp[i+n][i+n][0] = dp[i+n][i+n][1] = w[i];
    }
    for(int len=2;len<=n;len++)
        for(int l=1;l<=2*n-len+1;l++){
            int r = l + len - 1;
            dp[l][r][0] = -1e9,dp[l][r][1] = 1e9;
            for(int k=l;k<r;k++){
                if(op[k+1] == 't'){
                    dp[l][r][0] = max(dp[l][k][0]+dp[k+1][r][0],dp[l][r][0]);
                    dp[l][r][1] = min(dp[l][k][1]+dp[k+1][r][1],dp[l][r][1]);
                }else{
                    for(int p=0;p<=1;p++)
                        for(int q=0;q<=1;q++){
                            dp[l][r][0] = max(dp[l][k][p]*dp[k+1][r][q],dp[l][r][0]);
                            dp[l][r][1] = min(dp[l][k][p]*dp[k+1][r][q],dp[l][r][1]);
                        }
                }
            }
        }
    int ans = -1e9;
    for(int i=1;i<=n;i++) ans = max(ans,dp[i][i+n-1][0]);
    cout<<ans<<endl;
    for(int i=1;i<=n;i++)
        if(dp[i][i+n-1][0] == ans) cout<<i<<" ";
    cout<<endl;
    return 0;
}

树形DP

没有上司的舞会

解释

有强烈的自下向上推，想知道当前的人是否选择的最优价值，必须知道它儿子的最优价值。

状态表示 设dp（i，0）表示第i个人不选的最大值,dp（i，1）为第i个人选的最大值。

目标状态 max（dp（i，0），dp（i，1）… ）

转移方程

初始dp（i，1） = w（i）

dp（i，1）+= dp（j，0） j 属于 i的儿子节点

dp（i，0）+= max（dp（j，0），dp（j，1））

模板

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e4 + 10;

int dp[N][2],w[N],d[N];
int h[N],e[N],ne[N],idx=1;

void add(int a,int b){
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u){
    dp[u][1] = w[u];
    for(int i=h[u];i;i=ne[i]){
        int j = e[i];
        dfs(j);
        dp[u][1] += dp[j][0];
        dp[u][0] += max(dp[j][1],dp[j][0]);
    }
}

int main(){
    int n; cin>>n;
    for(int i=1;i<=n;i++) cin>>w[i];
    for(int i=1;i<n;i++){
        int a,b; cin>>a>>b;
        add(b,a); d[a] ++;
    }
    int root = 1;
    while(d[root]) root ++;
    dfs(root);
    int ans = -1e9;
    for(int i=1;i<=n;i++) ans= max(ans,max(dp[i][0],dp[i][1]));
    cout<<ans<<endl;
    return 0;
}

二叉苹果树

解释

树形DP + 分组背包

选择边的问题

普通分组背包，第一层枚举组，相当于枚举儿子节点dfs处理，第二层枚举体积，第三层枚举每一组里面每一个的物品。状态表示dp（i，j）。然后第一层可以优化掉，只需要体积逆序。

对于树形，有依赖，必须开一维存当前的根节点。即用dp（i，j）表示。

对于每一个儿子节点。都互不影响，可以看成不同的组，对于每一组，可以选择0~m个保留每一个的价值为dp（j，0…m）体积为 0…m

状态表示 dp（i，j）表示当前以i为节点，保留j条边所得到的最大值。

目标状态 dp（1，m）

状态转移 当前父节点保留i个时。对于当前的儿子节点，选j个时。

dp（u，i）= max（dp（u，i），dp（u，i-j-1）+ dp（v，j）+ w）

(i - j - 1) 减 1是，若当前选了子树，必须拿一个边出来连接。

模板

#include<bits/stdc++.h>
using namespace std;
const int N = 1e3+10;

int dp[N][N],n,m;
int e[N],w[N],ne[N],h[N],idx=1;

void add(int a,int b,int c){
	w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u,int fa){
	for(int i=h[u];i;i=ne[i]){
		int j = e[i];
		if(j == fa) continue;
		dfs(j,u);
		for(int x=m;x;x--)
			for(int y=0;y<=x-1;y++)
				dp[u][x] = max(dp[u][x],dp[u][x-y-1]+dp[j][y]+w[i]);
	}
}

int main(){
    cin>>n>>m;
    for(int i=1;i<n;i++){
    	int a,b,c; cin>>a>>b>>c;
    	add(a,b,c);add(b,a,c);
	}
    dfs(1,0);
    cout<<dp[1][m]<<endl;
	return 0;
}

选课

选择点的问题。

模板

#include<bits/stdc++.h>using namespace std;const int N = 1e3+10;int dp[N][N],n,m;int e[N],w[N],ne[N],h[N],idx=1;void add(int a,int b){	e[idx]=b,ne[idx]=h[a],h[a]=idx++;}void dfs(int u){	for(int i=h[u];i;i=ne[i]){		int j = e[i];		dfs(j);		for(int x=m-1;x;x--)			for(int y=1;y<=x;y++)				dp[u][x] = max(dp[u][x],dp[u][x-y]+dp[j][y]);	}	for(int i=m;i;i--) dp[u][i] = dp[u][i-1] + w[u];}int main(){    cin>>n>>m; m += 1;    for(int i=1;i<=n;i++){    	int a; cin>>a>>w[i];    	add(a,i);	}    dfs(0);    cout<<dp[0][m]<<endl;	return 0;}

树形DP之换根DP

积蓄程度

解释

先以任意度数不为1的任意节点为根节点（没有直接输出w（1）），求出d数组，表示以当前这个节点为父节点时，流向儿子节点的最大流量。

即可以得到d（u） += min（w（i），d（j））当前这个节点流量等于它到儿子节点最大的通量和儿子最大能接受的量。

当处理完后，再进行一次处理。设dp（i）表示以i为根节点时（源节点）最大流量。dp（root） = d（root）

然后根据父亲推出儿子节点的dp值。

假设当前父节点为u，子节点时j，dp（j） = d（j） + min（w（i），流向它父亲节点的流量）

流向它父亲的流量等于父节点流向除j之外的节点的流量

父节点流向除j之外的节点的流量 = dp（u）- min（d（j），w（i））

所以dp（j） = d（j） + min（w（i），dp（u）- min（d（j），w（i）））

对于儿子节度数为1，dp（j） = min（w（i），dp（u） - w（i））

模板

#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);#include<bits/stdc++.h>using namespace std;const int N = 4e5+10;int dp[N],d[N],deg[N];int w[N],ne[N],h[N],e[N],idx=1;void add(int a,int b,int c){	w[idx]=c,e[idx]=b,ne[idx]=h[a],h[a]=idx++;}void pre_dfs(int u,int fa){	for(int i=h[u];i;i=ne[i]){		int j = e[i];		if(j == fa) continue;		pre_dfs(j,u);		if(deg[j] == 1) d[u] += w[i];		else d[u] += min(d[j],w[i]);	}}void dfs(int u,int fa){	for(int i=h[u];i;i=ne[i]){		int j = e[i];		if(j == fa) continue;		if(deg[j] == 1) dp[j] = min(w[i],dp[u]-w[i]);		else dp[j] = d[j] + min(w[i],dp[u]-min(d[j],w[i]));		dfs(j,u);	}}signed main(){	IOS    int tt; cin>>tt;    while(tt --){    	idx = 1;    	int n; cin>>n;    	for(int i=1;i<=n;i++) dp[i] = d[i] = deg[i] = h[i] = 0;		for(int i=1;i<n;i++){			int a,b,c; cin>>a>>b>>c;			add(a,b,c);add(b,a,c);			deg[a]++,deg[b]++;		}		int root = 1;		while(deg[root] == 1 && root <= n) root ++;		if(root > n){			cout<<w[1]<<endl;			continue;		}		pre_dfs(root,0);		dp[root] = d[root];		dfs(root,0);		int ans = 0;		for(int i=1;i<=n;i++) ans = max(ans,dp[i]);		cout<<ans<<endl;	}	return 0;}

概率DP

codeforces148D

解释

设dp（i，j）为当前背包中有i个白鼠，j个黑鼠时，公主赢的概率。

初始化，当背包中只有白鼠时，赢的概率为1.

分情况：

1：公主第一次取到白鼠。赢得概率为 $\frac{i}{i+j}$

2：公主取到黑鼠，龙取到黑鼠，跑出一只黑鼠。公主赢的概率只有在dp（i，j-3）的情况下发生，而当前情况发生的概率为s = $\frac{j}{i+j-1}*\frac{j-1}{i+j-1}*\frac{j-2}{i+j-2}$ ,所以赢的概率为 s $\times$ dp（i，j-3）。

3：公主取到黑鼠，龙取到黑鼠，跑出一只白鼠。公主赢的概率只有在dp（i-1，j-2）的情况下发生，而当前情况发生的概率为s = $\frac{j}{i+j-1}*\frac{j-1}{i+j-1}*\frac{i}{i+j-2}$ ,所以赢的概率为 s $\times$ dp（i - 1，j - 2）。

代码

#include<iostream>#include<cstring>#include<algorithm>#include<iomanip>using namespace std;const int N = 1e3+10;double dp[N][N];signed main(){    int n,m; cin>>n>>m;    for(int i=1;i<=n;i++) dp[i][0] = 1;    for(int i=1;i<=n;i++)    	for(int j=1;j<=m;j++){    		double a = i,b = j;    		dp[i][j] += a/(a+b);    		if(j >= 3)				dp[i][j] += b/(a+b)*(b-1)/(a+b-1)*(b-2)/(a+b-2)*dp[i][j-3];    		if(i >= 1 && j >= 2)    			dp[i][j] += b/(a+b)*(b-1)/(a+b-1)*a/(a+b-2)*dp[i-1][j-2];		}    cout<<fixed<<setprecision(9)<<dp[n][m]<<endl;	return 0;}

期望DP

CollectingBugs

解释

设dp（i，j）表示找到i个bug,属于j个子系统到目标状态还需要的期望天数，则dp（n，s） = 0.

假设当前找到的bug属于之前找到的bug ，也属于找到的子系统，那么dp（i，j） = dp（i，j） $\times$ $\frac{i}{n}\times\frac{j}{s}$

同理当前找到的bug不属于之前找到的bug，属于找到的子系统，那么dp（i，j） = dp（i+1，j） $\times$ $\frac{n-i}{n}\times\frac{j}{s}$

当前找到的bug属于之前找到的bug，不属于找到的子系统，那么dp（i，j） = dp（i，j+1） $\times$ $\frac{i}{n}\times\frac{s-j}{s}$

当前找到的bug不属于之前找到的bug，不属于找到的子系统，那么dp（i，j） = dp（i+1，j+1） $\times$ $\frac{n-i}{n}\times\frac{s-j}{s}$

期望次数加1，因为无论哪种情况，天数都会加1.

dp（i，j）= dp（i，j） $\times$ $\frac{i}{n}\times\frac{j}{s}$ + dp（i+1，j） $\times$ $\frac{n-i}{n}\times\frac{j}{s}$ + dp（i，j+1） $\times$ $\frac{i}{n}\times\frac{s-j}{s}$ + dp（i+1，j+1） $\times$ $\frac{n-i}{n}\times\frac{s-j}{s}$ + 1.

$\Longleftrightarrow$ （dp（i+1，j） $\times$ $\frac{n-i}{n}\times\frac{j}{s}$ + dp（i，j+1） $\times$ $\frac{i}{n}\times\frac{s-j}{s}$ + dp（i+1，j+1） $\times$ $\frac{n-i}{n}\times\frac{s-j}{s}$ + 1）/ （1 - $\frac{i}{n}\times\frac{j}{s}$ ）。注意除0得情况。

代码

#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);#include<iostream>#include<iomanip>#define int long longusing namespace std;typedef long long ll;const int eps = 1e-7;const int N = 1e3+10;double dp[N][N];signed main(){    IOS    int n,s; cin>>n>>s;    int t = n*s;    for(int i=n;i>=0;i--)    	for(int j=s;j>=0;j--){    		if(i == n && j == s) continue;    		double p1 = 1.0*i*j/t,p2 = 1.0*(n-i)*j/t;    		double p3 = 1.0*i*(s-j)/t,p4 = 1.0*(n-i)*(s-j)/t;    		dp[i][j] = (p2*dp[i+1][j] + p3*dp[i][j+1] + p4*dp[i+1][j+1] + 1)/ (1-p1);		}    cout<<fixed<<setprecision(4)<<dp[0][0]<<endl;	return 0;}

数位DP

windy数

解释

数位DP就是按这个数的每一位数来分析进行DP.从高位往低位走

题目可以转换为求1~l-1（a）, 1~r（b）的值，最后答案即为 b - a。

首先，对于给定范围，为了让所有的数不大于最右边的数，加一个限制，具体如下，假设最右边的数为b,当前枚举的数为a。再形成a这个数的过程中（因为按高位往低位形成），若上一位及其前面的位与b上对应的位都相同，那么当前这位枚举就有限制，限制在0 ~ b（pos），否则，那么限制打开，可以枚举0 ~ 9，注意前导零处理

之后可以用dfs求解dp（n，last）（n位，last(上一个)，op（限制））因为当n,last，op相同时，得到的子问题是一样的解集。所以可以用记忆化搜索优化，注意记忆化一定要当op限制解除的时候再记忆化。具体再看博客

介绍。

对于某些题，前导0也会对记忆化产生影响。

模板

#define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);#include<iostream>#include<algorithm>#include<cstring>#include<cmath>#include<vector>using namespace std;const int N = 1e2 + 10;int dp[N][N];vector<int> s;int dfs(int n,int last,int op){	if(!n) return 1;	if(!op && ~dp[n][last]) return dp[n][last];	int ma = op ? s[n] : 9;	int res = 0;	for(int i=0;i<=ma;i++){		if(abs(last - i) < 2) continue;		if(last == 11 && i == 0) res += dfs(n-1,11,op & (i == ma));		else res += dfs(n-1,i,op & (i == ma));	}	if(!op) dp[n][last] = res;	return res;} int slove(int x){	memset(dp,-1,sizeof(dp));	s.clear();	s.push_back(-1);	while(x){		s.push_back(x % 10);		x /= 10;	}	return dfs((int)s.size()-1,11,1);}signed main(){    IOS    int l,r; cin>>l>>r;    cout<<slove(r) - slove(l-1)<<endl;        return 0;}

状压DP

多用二进制表示状态，进行状态之间的转移。

蒙德里安的梦想

解释

以一行为边界，会发现，这行竖着放的下一行一定会被填，用二进制中的1表示当前行是竖着放的，

那么下一行的状态合法必须满足：

上一行与下一行的与为0，表示上一行竖着放的，下一行一定为0补全上一行，而上一行为0的，当前行可以为1也可以为0.
上一行与下一行的状态或上的状态，一定是连续的0的个数为偶数，因为与上之后，还为0的只有放横着的，横着的必须为偶数个。

每次先处理合法状态，存到数组里面。之后枚举当前行，当前的状态，再枚举上一行的状态，判断当前行是否可以由上一行转移过来。

代码

#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);#include<bits/stdc++.h>#define int long longusing namespace std;const int N = 11;int vis[1<<N],dp[N+1][1<<N]; signed main(){	IOS    int n,m;    while(cin>>n>>m && n && m){        for(int i=0;i<(1 << m);i++){    	int odd = 0,cnt = 0;    	for(int j=0;j<m;j++)    		if((i >> j) & 1) odd |= cnt,cnt = 0;    		else cnt ^= 1;    	vis[i] = (odd | cnt) ? 0 : 1;	}    	dp[0][0] = 1;    	for(int i=1;i<=n;i++)    		for(int j=0;j<(1 << m);j++){    			dp[i][j] = 0;    			for(int k=0;k<(1 << m);k++)    				if(!(j & k) && vis[j | k])    					dp[i][j] += dp[i-1][k];			}    	cout<<dp[n][0]<<endl;	}	return 0;}