标签：ace special strong continue 转移 无法 add int 是什么
简而言之，树形dp，就是在树形结构上的动态规划，由于树形结构具有一定的特点，可以描述比较复杂的关系，再加上树的递归定义，是一种非常合适动规的框架，属于动规中很特殊的一种类型。
如何实现树形\(dp\)?
树形dp的状态表示中，第一位通常是节点编号（代表以该节点为根的子树），大多数时候，我们采用递归的方式实现树形动态规划。对于每个节点x，我们先递归x的所有子节点，并在其子节点上dp，在回溯时，从子节点向节点x进行状态转移。
树形\(dp\)的分类
常用dp套路：
定义状态：f[i][0/1]表示在以i号节点为根的子树中，i号节点是（1）否（1）选择所能造成的最大或最小贡献.定义状态：f[i][j]表示在以i号节点为根的子树中，选择j个节点或边所得的最大值或最小值递归实现树形dp的方法
inline void dfs(int x,int fa)//fa是x的父亲节点
{
for(int i=head[x];i;i=Next[i])//邻接表常规便利
{
int y=ver[i];
if(y==fa) continue;
dfs(y,x);
/*dp具体内容*/
}
}对于有根树，即从题面中我们很容易可以看出是一张有向图（如“没有上司的舞会”），对于这种情况我们可以加两次边，把它当做无根树用上述模板来处理，或者在原有向图中找出一个根，再以此递归。
inline void dfs(int x)
{
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
dfs(y);
//dp
}
}//找根可以用其入度为零这一特点来找，这里不再介绍。注：后文代码仅给出核心部分，涉及到的基础函数将在这里给出
邻接表加边函数：
inline void add(int x,int y,int z)
{
ver[++tot]=y;
Next[tot]=head[x];
head[x]=tot;
edge[tot]=z;
}快读函数：
inline int read()
{
int num=0,w=1;char ch=getchar();
while(ch<'0' || ch>'9'){if(ch=='-') w=-1;ch=getchar();}
while(ch<='9' && ch>='0')
num=(num<<1)+(num<<3)+ch-'0',ch=getchar();
return num*w;
}宏定义：
#define Mi return
#define manchi 0后文除第一个例题外，都只叙述无向图的解法。
很容易看出这是个选择节点类的树形dp，因为题目对于选择职员的数量并没有限制。
那么我们依据套路定义dp状态：
定义状态：
f[i][1]表示在以i号节点为根的子树中，i号职员来参加舞会所得的最大快乐指数
f[i][0]则表示i号职员不来参加所得的最大快乐指数接下来我们明确父子关系：如果某个职员的上司来参加舞会了，那么这个职员就无论如何也不肯来参加舞会了，即父亲与儿子不能共存。
然后以此进行状态转移：
状态转移：
f[i][1]+=max(f[son][0])//由于i去了,所以i的儿子就不能去了,即f[son][0]
f[i][0]+=max(f[son][1],f[son][0])//i没有去,那么i的儿子可去可不去考虑边界:
f[i][1]=happy[i]//初始状态去参加舞会的快乐指数肯定等于自身的快乐指数然后套上dfs就能A掉了，\(QwQ\).
Code(有向图):
const int N = 6000+5;
int n,happy[N],root;
int head[N],ver[N<<1],tot,Next[N<<1];
int f[N][3];bool vis[N];//vis数组用于找根
//f[i][0]以i为根,i不去;f[i][1]以i为根,i去
//f[i][0]+=max(f[j][0],f[j][1]),j是i的儿子
//f[i][1]+=max(f[j][0])
inline void slove(int x)
{
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
slove(y);
//dp
f[x][0]+=max(f[y][0],f[y][1]);
f[x][1]+=f[y][0];
}
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
f[i][1]=read();//直接读入的时候初始化
for(int i=1;i<=n-1;i++)
{
int x=read(),y=read();
vis[x]=1;add(y,x);
}int a=read(),b=read();
//找根
for(int i=1;i<=n;i++)
if(!vis[i]){root=i;break;}
slove(root);
cout<<max(f[root][1],f[root][0]);//输出答案
return 0;
}Code(无向图):
inline void dfs(int x,int fa)
{
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
if(y==fa) continue;
dfs(y,x);
f[x][0]+=max(f[y][0],f[y][1]);
f[x][1]+=f[y][0];
}
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
f[i][1]=read();
for(int i=1;i<=n-1;i++)
{
int x=read(),y=read();
add(y,x);add(x,y);//注意加两次边，转为无向图
}int a=read(),b=read();
dfs(1,0);//任选一个点作为根进行dp,这里选择1作为根.
cout<<max(f[1][1],f[1][0]);
return 0;
}由于对于选择的花数量没有限制，这显然是一道节点选择类的树形dp，再确定父子关系：父亲不选择，儿子就无法选择（这点显然），那就直接走套路就行了
const int N = 16000+5;
/*
定义状态：
f[i][1]表示在以i号节点为根的子树中，选择第i号花所得最大美丽指数
f[i][0]则表示不选择i号花的最大美丽指数
状态转移：
f[i][1]+=max(f[son][0],f[son][1])
f[i][0]=0
边界:
f[i][1]=a[i]
*/
int n,f[N][2],root,a[N],ans=-0x7fffffff;
int ver[N<<1],head[N<<1],Next[N<<1],tot;
inline void dfs(int x,int fa)
{
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
if(y==fa) continue;
dfs(y,x);
f[x][0]=0;
f[x][1]+=max(f[y][1],f[y][0]);
}
}
int main()
{
n=read();
for(int i=1;i<=n;i++) f[i][1]=read();
for(int i=1;i<=n-1;i++)
{
int x=read(),y=read();
add(y,x),add(x,y);
}
dfs(1,0);
for(int i=1;i<=n;i++)
ans=max(ans,f[i][1]);
printf("%d",ans);
Mi manchi;
}显然是一道节点选择类的树形dp，确定父子关系：父亲和儿子中有一个存在即可（只要存在一个，那么父亲与儿子之间的这条边就可以被覆盖）。
都是套路\(QwQ\)
const int N = 1500+5;
/*
定义状态：
f[i][0]表示以i为根的子树,i结点不放士兵的最小值
f[i][1] 放士兵的最小值
状态转移：
f[i][0]+=f[son][1]//父亲不选择的话,儿子就一定要选择才符合题意
f[i][1]+=min(f[son][1],f[son][0]);//父亲选择了的话,那么儿子选不选都可以.
边界:
f[i][1]=1
ans=min(f[i][1],f[i][0])
*/
int n,f[N][2];
int tot,head[N],ver[N],Next[N];
inline void dfs(int x,int fa)
{
f[x][1]=1;
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
if(y==fa) continue;
dfs(y,x);
f[x][1]+=min(f[y][1],f[y][0]);
f[x][0]+=f[y][1];
}
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
{
int x=read(),k=read();
for(int j=1;j<=k;j++)
{
int y=read();
add(x,y);add(y,x);
}
}
dfs(1,-1);//注意是从节点0开始编号的,所以我们选的root的fa不能为0
printf("%d",min(f[1][0],f[1][1]));
Mi manchi;
}上面都是挺水的题目，接下来看一道有点思维难度的题目。
我们发现这题和战略游戏那题很像，但是战略游戏关注的是边，而这题关注的是点有没有被覆盖，所以我们就要重新确定父子关系，并重新定义状态。
父子关系:
自己(i),父亲(fa),儿子(son)中必须要存在一个
定义状态：
f[i][0]表示i被自己覆盖 的最小花费
f[i][1]表示i被儿子覆盖 的最小花费
f[i][2]表示i被父亲覆盖 的最小花费
状态转移：
1.f[i][0]+=min(f[son][1],f[son][2],f[son][0])
2.f[i][1]=f[x][0]+sigma(min (f[son][0],f[son][1]) )
3.f[i][2]+=min(f[son][0],f[son][1])
我们分析一下上面状态转移的过程：
1.此时情况是节点i处放置警察，那么它的儿子可以选择被自己看守(f[son][0])，也可以选择被儿子看守(f[son][1]),当然也可以选择被父亲看守(f[son][2])
转移2有点小难度，我们先分析转移3
3.此时的情况是节点i被父亲覆盖(即i节点没有放置警察),那i的儿子(son)就只能选择被自己看守(f[son][0]),或者被它的儿子的看守(f[son][1])现在讨论转移2：
此时的情况是节点\(i\)处不放置警察，节点\(i\)由它的儿子看守，那么我们显然要在\(i\)的众多儿子中，选择一个儿子(对应上面转移方程中的\(x\))放置警察，这样当前节点\(i\)才会被看守到，然后对于剩余的儿子，我们进行和转移方程3一样的操作就可以了，因为此时节点\(i\)没有放置警察，那\(i\)的儿子就只能选择被自己看守,或者被它的儿子的看守。
那么我们只需要找到对于节点\(i\)来说，一个最优的儿子\(x\)就行了，可以考虑枚举所有儿子，但是也有数学方法来优化，以下内容参考
对于x来说，有\(f[i][1]=f[x][0]+\Sigma_{j\subset son(i),j!=x}{min(f[j][0],f[j][1])}\)
若x不是最优的，则存在y满足\(f[x][0]+\Sigma_{j\subset son(i),j!=x}{min(f[j][0],f[j][1])}<f[y][0]+\Sigma_{j\subset son(i),j!=y}{min(f[j][0],f[j][1])}\)
合并同类项，整理得\(f[x][0]-min(f[x][0],f[x][1])>f[y][0]-min(f[y][0],f[y][1])\)
所以对于最优的x，只需要满足\(f[x][0]-min(f[x][0],f[x][1])\)是所有儿子中最小的就可以了。
我们不妨设最优的\(x\)一开始为0，然后对\(f[0][0]\)赋一个极大值来转移
const int N = 1500+5;
int n,f[N<<1][3];
int tot,head[N],ver[N<<1],Next[N<<1];
inline void dfs(int x,int fa)
{
int special_son=0;
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
if(y==fa) continue;
dfs(y,x);
f[x][0]+=min(f[y][0],min(f[y][1],f[y][2]));
f[x][2]+=min(f[y][0],f[y][1]);
//找最优的x
if((f[special_son][0]-min(f[special_son][0],f[special_son][1])) > (f[y][0]-min(f[y][0],f[y][1])))
special_son=y;
}
//找到x之后,我们还需要求出simga(min (f[j][0],f[j][1]) )
f[x][1]=f[special_son][0];
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
if(y==fa || y==special_son) continue;
f[x][1]+=min(f[y][0],f[y][1]);
}
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
{
int x=read(),val=read(),k=read();
f[x][0]=val;//初始化
for(int j=1;j<=k;j++)
{
int y=read();
add(x,y);add(y,x);
}
}
f[0][0]=0x3f3f3f3f;dfs(1,-1);//赋初值
printf("%d",min(f[1][0],f[1][1]));
Mi manchi;
}通过上一道例题我们可以发现，节点选择类的树形dp，其状态的第二维，就不只局限于是否选择当前这个节点，而是针对题意拓展为当前这个点的状态是什么，就如上一道例题，状态的第二维表示的是节点\(i\)的具体被看守情况。我们再来看一道例题。
这道题目相对简单，可以说是节点选择类dp的进阶练手题，此时我们如果还用\(f[i][0/1]\)来表示i节点是否染成绿色的话，显然是无法解决问题的，所以我们要考虑拓展第二维，这拓展是很好想的。由于最大值和最小值得求法本质是类似的，故下面只叙述最大值的做法
定义状态：
f[i][0/1/2]表示在以i为根的子树中,染色绿色的最多个数
且i的颜色为 0/1/2 (绿/红/蓝)接下来我们确定父子关系，然后依据具体情况转移就行了。
明确父子关系:父亲和儿子状态不能相同,儿子和儿子之间状态也不能相同
状态转移:
1.i为绿色,那么左右儿子只能为红或蓝
f[i][0]=max(f[lson][1]+f[rson][2],f[lson][2]+f[ron][1])+1
2.i为红/蓝
f[i][1]=max(f[lson][0]+f[rson][2],f[lson][2]+f[rson][0]);
f[i][2]=max(f[lson][1]+f[rson][0],f[lson][0]+f[rson][1]);
初始f[i][0]=1,f[i][1/2]=0;
ans=max(f[1][0/1/2]) 本题对于树的结构是有严格限制的，即只能有一个儿子或者两个儿子，那么我们就可以用数组来模拟这棵树，而非用领接表加边建树。
using namespace std;
const int N = 500000+5;
int f[N][3],g[N][3];
int tot,tree[N][2];
//数组模拟这棵树,tree[i][0/1]表示以i为根的树中,左/右儿子的编号
char TREE[N];
inline void build(int root)//递归建树
{
tot++;
if(TREE[root]=='0') return;
else if(TREE[root]=='1') {tree[root][0]=tot+1;build(tot+1);return;}
else if(TREE[root]=='2') {tree[root][0]=tot+1;build(tot+1);tree[root][1]=tot+1;build(tot+1);return;}
}
inline void dfs(int fa)
{
f[fa][0]=g[fa][0]=1;
if(tree[fa][0] && tree[fa][1])//左右儿子都有
{
int l=tree[fa][0],r=tree[fa][1];
dfs(l);dfs(r);
f[fa][0]=max(f[l][1]+f[r][2],f[l][2]+f[r][1])+1;
f[fa][1]=max(f[l][0]+f[r][2],f[l][2]+f[r][0]);
f[fa][2]=max(f[l][1]+f[r][0],f[l][0]+f[r][1]);
g[fa][0]=min(g[l][1]+g[r][2],g[l][2]+g[r][1])+1;
g[fa][1]=min(g[l][0]+g[r][2],g[l][2]+g[r][0]);
g[fa][2]=min(g[l][1]+g[r][0],g[l][0]+g[r][1]);
}
else if(tree[fa][0] && !tree[fa][1])
{
int son=tree[fa][0];
dfs(son);
f[fa][0]=max(f[son][1],f[son][2])+1;
f[fa][1]=max(f[son][0],f[son][2]);
f[fa][2]=max(f[son][0],f[son][1]);
g[fa][0]=min(g[son][1],g[son][2])+1;
g[fa][1]=min(g[son][0],g[son][2]);
g[fa][2]=min(g[son][0],g[son][1]);
}
}
int main()
{
scanf("%s",TREE+1);build(1);
dfs(1);
printf("%d ",max(f[1][0],max(f[1][1],f[1][2])));
printf("%d",min(g[1][0],min(g[1][1],g[1][2])));
Mi manchi;
}不是很人性的题意翻译：给定一棵树，要求在树中选择节点染成黑色或白色，使得从根节点到叶子结点的简单路径上至少包含一个有色节点，同时给出限制\(c[i]\)，要求在从根节点到\(i\)号叶子节点的简单路径中，最后一个有色节点的颜色为\(c[i]\)，求需要选择着色的最少节点数。
本质上仍然是节点选择类的树形dp，其状态与上一道例题很相似，这里先给出整体思路。
/*
定义状态:
f[i][0/1/2]表示在以i为根的子树中,i的颜色为(黑色/白色/不染色)所需染色的最小值
确定父子关系:
保证根结点到每个叶子的简单路径上都至少包含一个有色结点
状态转移:
贪心地去想,保证简单路径上都包含一个有色节点,显然是将这个有色节点放得越高越好,
即让经过这个有色节点的简单路径数增多.
考虑c[i]这个限制条件,我们只要固定第i个节点的颜色就可以了
1.如果i节点染成黑色,那我们的子节点就不用染成黑色。
由于是最少的着色节点，所以我们父亲的值显然为sigma(son)，所以用f[i][]+=
f[i][0]+=min(f[son][0]-1,f[son][1],f[son][2])
2.如果i节点染成白色
f[i][1]+=min(f[son][0],f[son][1]-1,f[son][2])
3.如果当前节点不染色
不染色的实质是因为无法确定当前节点要染黑色还是白色,还要看fa的情况
f[i][2]+=min(f[son][0/1/2])
边界:f[i][0]=f[i][1]=f[i][2]=1; f[i][2]的实质是染了一个不确定的颜色，所以其初始值也为1
f[i][!(c[i])]=INF;即i号节点绝对不能染成与c[i]相反的颜色，这点很显然
答案:ans=min(f[i][0/1/2])
*/贪心策略：
若某结点的儿子结点中需要染黑色的比白色多，就将此节点标记为要染黑色，把要染白色的儿子染成白色；
例如节点\(i\)有三个儿子，其中两个儿子需要染成黑色才符合条件，另一个则需要染成白色，那么我们显然应该把节点\(i\)染成黑色，这样它的两个儿子就不需要染色了，只需要将另一个儿子染成白色即可。
儿子节点中需要染成白色的比黑色的多，同理。
那还有一种情况就是要染成黑色和白色的个数一样多，那么我们这时就考虑先不染色，看看\(i\)的兄弟的情况再具体染色，例如节点\(i,j\)是兄弟，其父亲为\(fa\)，\(i\)节点暂时没有染色（可以染成任意颜色），\(j\)节点需要染成黑色，那么我们显然应该把\(i\)节点看成黑色，此时\(fa\)就需要染成黑色，\(i,j\)就不用染色，这样显然是最优的。
以上策略参考（建议阅读）:
const int N = 100500;
const int INF = 0x3f3f3f3f;
int n,m,tot,c[N],f[N][3];
int ver[N<<1],head[N],Next[N<<1];
inline void dfs(int x,int fa)
{
if(x<=m) return ;
for(int i=head[x];i;i=Next[i])
{
int y=ver[i];
if(y==fa) continue;
dfs(y,x);
f[x][0]+=min(f[y][0]-1,min(f[y][2],f[y][1]));
f[x][1]+=min(f[y][0],min(f[y][2],f[y][1]-1));
f[x][2]+=min(f[y][0],min(f[y][1],f[y][2]));
}
}
int main()
{
n=read();m=read();
for(int i=1;i<=m;i++) c[i]=read();
for(int x,y,i=1;i<n;i++)
{
x=read(),y=read();
add(x,y);add(y,x);
}
for(int i=1;i<=n;i++)
{
f[i][0]=f[i][1]=f[i][2]=1;
if(i<=m) f[i][!(c[i])]=INF;
}
dfs(m+1,-1);//以一个不是叶子节点的根 dfs
printf("%d",min(f[m+1][1],min(f[m+1][0],f[m+1][2])));
Mi manchi;
}标签：ace special strong continue 转移 无法 add int 是什么
原文地址：https://www.cnblogs.com/fengzi8615/p/11768259.html
