区间dp 和 树型dp
Posted --Lance
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了区间dp 和 树型dp相关的知识，希望对你有一定的参考价值。
区间dp
递推方程是以区间的形式给出 一般套路 ：枚举区间长度 区间端点 区间分界点
然后就是想怎么去对这个区间进行一定的操作 从最原始的地方开始一步步推导方程！
for(i=1;i<n;i++)//区间长度为1
for(j=1;j<=n-i;j++) //区间开头
for(k=j;k<j+i;k++) //分界点
f[j][j+i]=min(f[j][j+i],f[j][k]+f[k+1][j+i]+s[j+i]-s[j-1]);
g[j][j+i]=max(g[j][j+i],g[j][k]+g[k+1][j+i]+s[j+i]-s[j-1]);
如果区间是一个环形那就开2倍空间：去看从哪一个点断开的去枚举端点！！不妨为一个好思路
#include <bits/stdc++.h>
using namespace std;
int n;
int a[501],f[501][501],s[501];
int main()
cin>>n;
int i,j,k;
for(i=1;i<=n;i++)
cin>>a[i];
a[i+n]=a[i];
int t=n*2;
for(i=1;i<=t;i++)
s[i]=s[i-1]+a[i];
memset(f,127,sizeof(f));
for(i=1;i<=t;i++) //长度为0 的区间
f[i][i]=0;
for(i=1;i<t;i++) //因为转移方程 是由两个小区间转移到大区间
//故要按照区间大小进行排序先更新每一个小区间保证
//后面的区间更新时用到的值是有效的
for(j=1;j<=t-i;j++)//区间的开头
for(k=j;k<j+i;k++) //区间分界线
f[j][j+i]=min(f[j][j+i],f[j][k]+f[k+1][j+i]+s[j+i]-s[j-1]);
int ans=1<<30;
for(i=1;i<=n;i++)
ans=min(ans,f[i][i+n-1]);
cout<<ans;
这个地方就是去看那一段长度为n 的子区间最小 应为是断点从什么地方开始断开之后形成的
相当于把区间分成了两份往断口合并！
主要就是看如何对这一个区间的东西进行一定的操作！！！来达到目的的实现！！
当然也有变种也就是给定一个原始区间对该原始区间进行dp 添加或者减少数字！！
#include <bits/stdc++.h> //区间dp的好题目
using namespace std;
typedef int64_t i64;
int mod=19650827;
int a[1005];
int f[1005][1005][2];
int n;
int main()
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=1;i<=n;i++)
f[i][i][0]=1;
for(int k=1;k<n;k++)
for(int i=1,j=i+k;j<=n;j++,i++)
if(a[i]<a[i+1]) f[i][j][0]+=f[i+1][j][0];
if(a[i]<a[j]) f[i][j][0]+=f[i+1][j][1];
if(a[j]>a[i]) f[i][j][1]+=f[i][j-1][0];
if(a[j]>a[j-1]) f[i][j][1]+=f[i][j-1][1];
f[i][j][0]%=mod;
f[i][j][1]%=mod;
cout<<(f[1][n][0]+f[1][n][1])%mod;
这个就是一个原始区间然后不断去枚举添加数字！！看可以从那一个最开始的区间开始不断推导出新的东西!长度为 i+1的区间由长度为i的区间推导若开头是得到可以是j+1j+i也可以是从jj+i-1推导得到!!这个地方很好！！就是递推由小问题不断推出大问题，去写递推方程！！像递归的逆过程 递归就是大化小直至化为可以解决的东西
#include <bits/stdc++.h>
using namespace std;
int n,m;
inline __int128 read()
__int128 x = 0, f = 1;
char ch = getchar();
while(ch < \'0\' || ch > \'9\')
if(ch == \'-\')
f = -1;
ch = getchar();
while(ch >= \'0\' && ch <= \'9\')
x = x * 10 + ch - \'0\';
ch = getchar();
return x * f;
inline void print(__int128 x)
if(x < 0)
putchar(\'-\');
x = -x;
if(x > 9)
print(x / 10);
putchar(x % 10 + \'0\');
#define i128 __int128
i128 a[85];
i128 f[85][85]; //区间枚举！！
i128 ans; //答案记录！！
i128 base[85];
void solve()
for(int i=1;i<=m;i++)
for(int j=1;j<=m;j++)
f[i][j]=0;
for(int i=1;i<=m;i++)
a[i]=read();
// for(int i=1;i<=m;i++)
//
// //f[i][i]=2*a[i];//这是每次取走一个元素!!
// print(a[i]);
// cout<<endl;
//
//print(base[5]);
//cout<<endl;
for(int i=1;i<=m;i++)
for(int j=m;j>=i;j--)
f[i][j]=max(f[i][j],f[i-1][j]+base[m-j+i-1]*a[i-1]);
f[i][j]=max(f[i][j],f[i][j+1]+base[m-j+i-1]*a[j+1]);
i128 mx=0;
for(int i=1;i<=m;i++)
mx=max(mx,f[i][i]+base[m]*a[i]);
// print(mx);
// cout<<endl;
ans+=mx;
int main()
cin>>n>>m;
base[0]=1;
for(int i=1;i<=m;i++)
base[i]=base[i-1]*2;
for(int i=1;i<=n;i++)
solve();
print(ans);
这道题用了 int 128 题目本身是不难的这也算是多了个东西！主要就是这道题记录的原因就是给一道int128使用的方法看看，以后可以参照这个模板去写，这道题倒是没什么！！像合唱队模型的变种一样！！
主要就是看是如何对区间进行操作 是一步步化还是可以将区间划分后合并的那种！！
针对不同问题写出递推方程即可
高贵的树形dp
树形dp有两种一种是根可变 一种是根不可变
其中也有一定的思维方式 根可变就是计算当一个节点为根和不为根的情况去讨论
根不可变就不断递归去解决它的子树！！！ 这个很有意思
高贵的树dp
常见题目:没有上司的舞会 直接来变种 树上背包
#include <bits/stdc++.h>
using namespace std;
long long f[501][501][2];
int v[501];
int n,cnt,m;
struct node
int where;
node *next;
*head[501],a[501];
void makelist(int x,int y)
a[++cnt].where=y;
a[cnt].next=head[x];
head[x]=&a[cnt];
void dfs(int i)
for(node *x=head[i];x;x=x->next)
dfs(x->where);
for(int j=m;j>=0;j--)
for(int k=0;k<=j;k++)
f[i][j][0]=max(f[i][j][0],f[i][j-k][0]+max(f[x->where][k][0],f[x->where][k][1]));
f[i][j][1]=max(f[i][j][1],f[i][j-k][1]+f[x->where][k][0]);
for(int j=m;j;j--)
f[i][j][1]=f[i][j-1][1]+v[i];
f[i][0][1]=0;
int main()
cin>>n>>m;
int i;
for(i=2;i<=n;i++)
int x;
cin>>x;
makelist(x,i);
for(i=1;i<=n;i++)
cin>>v[i];
dfs(1);
cout<<max(f[1][m][0],f[1][m][1]);
这里主要就是有一个限制只能最多取m个人 所以要拿背包的思想做把人当作物品取枚举。故要注意背包的东西最大容量和每个物品最多有多少个！！然后枚举物品时注意枚举顺序！！要从大往下枚举！！这就是一道典型的树上背包题而且是较为简单的类型
2.
这道题就是一个很经典的另一个书上背包题
#include <bits/stdc++.h>
using namespace std;
typedef int64_t i64;
i64 dp[3005][3005];
int siz[3005];//子树大小 ！！
int n,m,cnt;
struct node
int v,where;
node *next;
a[3005],*head[3005];
int v[3005];
int ans;//计入多少个算进去的非根节点
void makelist(int x,int y,int z)
a[++cnt].where=y;
a[cnt].v=z;a[cnt].next=head[x];
head[x]=&a[cnt];
void solve(int x)
if(x>n-m)
siz[x]=1;
dp[x][1]=v[x];
return ;
for(node *y=head[x];y;y=y->next)
solve(y->where);
siz[x]+=siz[y->where];
// if(x==1)
for(int i=siz[x];i>=0;i--)
for(int j=0;j<=siz[y->where];j++)
// if(x==1)
//
// cout<<y->where<<\' \'<<y->v<<\' \';
// cout<<dp[x][1]<<\' \';
//
dp[x][i]=max(dp[x][i],dp[x][i-j]+dp[y->where][j]-(y->v));
int main()
cin>>n>>m;
memset(dp,237,sizeof(dp));
for(int i=1;i<=n;i++)
dp[i][0]=0;
for(int i=1;i<=n-m;i++)
int k;//有k个子节点
cin>>k;
for(int j=1;j<=k;j++)
int x,y;
cin>>x>>y;//节点编号 和 节点的成本
makelist(i,x,y);
for(int i=n-m+1;i<=n;i++)
cin>>v[i];
//cout<<dp[1][1];
solve(1);
//cout<<siz[5]<<\'\\n\';
for(int i=m;i>=1;i--)
if(dp[1][i]>=0)
// cout<<dp[1][i]<<\' \'<<i<<\' \'<<endl;
cout<<i;
return 0;
// cout<<endl;
// for(int i=1;i<=n;i++)
//
// for(int j=1;j<=n;j++)
//
// cout<<dp[i][j]<<\' \';
//
// cout<<\'\\n\';
//
去记录目标节点的数目就是用户节点的数目用用户节点的数目取枚举如果该子树有用户siz!=0否则siz==0，故用户数量是一个关键去看枚举的过程
但是如果该数是一个无根树的话
那么就会有限制条件要标记父亲就是不能一直访问的去
#include <bits/stdc++.h>
using namespace std;
int tot;
int siz[100005],st[100005];
int n,cnt,m;
struct node
int where;
node *next;
*head[100005],a[200010];
int dp[100005][55];
void makelist(int x,int y)
a[++cnt].where=y;
a[cnt].next=head[x];
head[x]=&a[cnt];
void dfs(int x)
st[x]=1;
for(node *y=head[x];y;y=y->next)
if(st[y->where]) continue;
dfs(y->where);
siz[x]+=siz[y->where];//这一步不也是同理
if(siz[y->where]) tot++;
for(int i=min(m,siz[x]);i>=0;i--)
for(int j=0;j<=min(siz[y->where],i);j++)
dp[x][i]=max(dp[x][i],dp[x][i-j]+dp[y->where][j]+(siz[y->where]&&siz[y->where]==j));
int main()
cin>>n>>m;
for(int i=1;i<n;i++)
int x,y;
cin>>x>>y;
makelist(x,y);
makelist(y,x);
int k;
cin>>k;
for(int i=1;i<=k;i++)
int x;
cin>>x;
siz[x]=1;
dfs(1);
cout<<2*(tot-dp[1][m]);
tot 是总的节点 个数要求的话 节点个数-1为边的个数 故就枚举走了多少条边 若该节点有目标节点则要走的边先对应要++ 之后去不断筛选得出答案
此外还有一种变种题 用递归去实现 子树的区间枚举 原因：给出树的方式很奇特！！如先序给出树的情况，
这道题目便是 那就很显然去用递归的思想去弄 每一个东西去枚举l r
很显然目前还不是特别特别懂！！但是可以化为区间dp 分界线为根 左边区间为左子树 右边区间为右子树！！这样不断枚举的去！！！达到想要的目的！！
#include <bits/stdc++.h>
using namespace std;
typedef int64_t i64;
i64 f[100][100];
int n;
int root[100][100];
void print(int l,int r)
if(l>r) return ;
cout<<root[l][r]<<\' \';
if(l==r) return;
print(l,root[l][r]-1);//左子树
print(root[l][r]+1,r);
int main()
cin>>n;
for(int i=1;i<=n;i++)
cin>>f[i][i];
root[i][i]=i;
f[i][i-1]=0;
for(int i=1;i<n;i++)
for(int j=1;j<=n-i;j++)
f[j][j+i]=f[j+1][j+i]+f[j][j];
root[j][j+i]=j;
for(int k=j+1;k<j+i;k++)
if(f[j][j+i]<f[j][k-1]*f[k+1][j+i]+f[k][k])
f[j][j+i] = f[j][k-1] * f[k+1][j+i] + f[k][k];
root[j][j+i]=k;
cout<<f[1][n]<<\'\\n\';
print(1,n);
故要注意
高贵的换根树dp
如何去dp呢
主要就是两步 该点为根与该点不为根的情况 up从下往上 down 从下往上弄一次！！
这种题目目前写的不多但是都很经典 ！！ 目前没做到多少题目！！到时候再弄弄把
POJ 2486 Apple Tree（树型dp）
| Time Limit: 1000MS | Memory Limit: 65536K | |
| Total Submissions: 8981 | Accepted: 2990 |
Description
Wshxzt is a lovely girl. She likes apple very much. One day HX takes her to an apple tree. There are N nodes in the tree. Each node has an amount of apples. Wshxzt starts her happy trip at one node. She can eat up all the apples
in the nodes she reaches. HX is a kind guy. He knows that eating too many can make the lovely girl become fat. So he doesn’t allow Wshxzt to go more than K steps in the tree. It costs one step when she goes from one node to another adjacent node. Wshxzt likes
apple very much. So she wants to eat as many as she can. Can you tell how many apples she can eat in at most K steps.
Input
There are several test cases in the input
Each test case contains three parts.
The first part is two numbers N K, whose meanings we have talked about just now. We denote the nodes by 1 2 ... N. Since it is a tree, each node can reach any other in only one route. (1<=N<=100, 0<=K<=200)
The second part contains N integers (All integers are nonnegative and not bigger than 1000). The ith number is the amount of apples in Node i.
The third part contains N-1 line. There are two numbers A,B in each line, meaning that Node A and Node B are adjacent.
Input will be ended by the end of file.
Note: Wshxzt starts at Node 1.
Each test case contains three parts.
The first part is two numbers N K, whose meanings we have talked about just now. We denote the nodes by 1 2 ... N. Since it is a tree, each node can reach any other in only one route. (1<=N<=100, 0<=K<=200)
The second part contains N integers (All integers are nonnegative and not bigger than 1000). The ith number is the amount of apples in Node i.
The third part contains N-1 line. There are two numbers A,B in each line, meaning that Node A and Node B are adjacent.
Input will be ended by the end of file.
Note: Wshxzt starts at Node 1.
Output
For each test case, output the maximal numbers of apples Wshxzt can eat at a line.
Sample Input
2 1 0 11 1 2 3 2 0 1 2 1 2 1 3
Sample Output
11 2
Source
POJ Contest,Author:[email protected]
难得1A 不枉这两天跟树dp天天见。
。
。
题目大意：一棵树。
。。
还是一棵树……每一个节点有一个点权。从树根出发，最远走k步，每走到一个新点。能够把该点的权值累加进去，问最多能够走出多大的权值和。
比較裸的树dp了。dp[i][j][0/1]表示根节点i開始走j步能够走出的最大权值和。近期做树型dp蛮多。发现大多都是这样。要开两个三维空间。一个表示答案。一个是用来辅助求解的。
此题相同，0表示走j步不回到根。1表示终于回到根。
这样发现每一个u来说。新遍历到一个孩子v，
dp[u][i][1]的更新为dp[u][i-j-2][1]+dp[v][j][1] 也就是说加上u到v这一步和从v遍历完返回u的v到u这步还有从v出发j步回到v 组成i
dp[u][i][0]的更新有两种，一种是到v后往后走完不回根 dp[u][i][0] = dp[u][i-j-1][1]+dp[v][j][0]
一种是v往后走完回根。然后从之前某个节点走完不回根 dp[u][i][0] = dp[u][i-j-2][0]+dp[v][j][1]
当然 上面这些都要取最大
代码例如以下：
#include <iostream>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#define LL long long
#define Pr pair<int,int>
#define fread() freopen("in.in","r",stdin)
#define fwrite() freopen("out.out","w",stdout)
using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const int mod = 1e9+7;
const double eps = 1e-8;
bool mp[111][111];
//0不回 1回
int dp[111][222][2];
int n,k;
int val[111];
void dfs(int u,int pre)
{
dp[u][0][0] = dp[u][0][1] = val[u];
for(int v = 1; v <= n; ++v)
{
if(v == pre || !mp[u][v]) continue;
dfs(v,u);
for(int i = k; i > 0; --i)
{
for(int j = 0; j < i; ++j)
{
if(j+2 <= i)
{
dp[u][i][1] = max(dp[u][i][1],dp[u][i-j-2][1]+dp[v][j][1]);
dp[u][i][0] = max(dp[u][i][0],dp[u][i-j-2][0]+dp[v][j][1]);
}
dp[u][i][0] = max(dp[u][i][0],dp[u][i-j-1][1]+dp[v][j][0]);
}
}
}
}
int main()
{
//fread();
//fwrite();
int u,v;
while(~scanf("%d%d",&n,&k))
{
memset(mp,0,sizeof(mp));
for(int i = 1; i <= n; ++i)
scanf("%d",&val[i]);
for(int i = 1; i < n; ++i)
{
scanf("%d%d",&u,&v);
mp[u][v] = mp[v][u] = 1;
}
memset(dp,0,sizeof(dp));
dfs(1,1);
int id = k;
while(id && !dp[1][id][0]) --id;
printf("%d\n",dp[1][id][0]);
}
return 0;
}
以上是关于区间dp 和 树型dp的主要内容，如果未能解决你的问题，请参考以下文章