[vijos1144]小胖守皇宫<树形dp>

题目链接：https://vijos.org/p/1144

woc我竟然A了，这道经典的树形dp或者说是树形dp的入门题我终于过了，虽然之前做过一些树形dp的题，但是这题开始还是一脸懵逼，dp方程如何定义都知道，但是不懂转移啊，这就有点伤了。。

dp方程定义dp[i][1]节点i 选自己

　　　　　dp[i][2]节点i选自己的儿子==不选自己和父亲

    　　　　dp[i][3]节点i选自己的父亲==不选自己选父亲

然后就是转移了。。毕竟是基础题嘛，所以转移也不难

转移的时候我们是直接递归到叶节点然后再做前面的。。所以我们不用考虑父节点的状态

dp[i][1]选自己的时候，儿子节点就有两种方式，选儿子自己，或者选儿子的父亲dp[i][1]+=min(dp[son][1],dp[son][3]);

dp[i][2]选儿子时 ，儿子就选或不选两个方式，但是如果一旦所有的儿子都是不选了，我们就要找一个最小的儿子树的值在最后加上，

dp[i][2]+=min(dp[son][1],dp[son][2])如果全部选了2，就要在结尾加上dp[i][2]+=min(dp[son][1]-dp[son][2])

至于为啥加这个，就是这道题唯一有点思考难度的地方了，因为你是要加最小的儿子选一个的值，所以找到最小，比如时第s2个儿子，之前已经加了dp[s2][2]，所以最后的时候是加上dp[s2][1]-dp[s2][2]，相当于把之前的那个dp[s2][2]抵消了，就不会加重复

dp[i][3]选父亲时，因为我们是从子往父推，所以不从父亲转移，就考虑这时候的儿子节点，儿子节点来源就是儿子自己放和儿子的儿子放

dp[i][3]+=min(dp[son][1],dp[son][2]);

好吧这就是这道题的全部了，最后只需要输出根节点的选自己和选儿子方案的最小值就可，因为根没有父亲。。。

储存这个关系的方式有两种，一种是链表，一种是多叉树转二叉树，

两种方式的不同点在于链表是双向的，然后重新建树，默认1为根节点

而多叉树转二叉树是以题目给的关系建树，以没有父亲的点为根

链表：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<queue>
#define maxn 1505
using namespace std;

int f[maxn][4],n;
struct edge{
    int u,v,w,nxt;
}e[maxn*10];
int a[maxn],head[maxn],vis[maxn],tot;

void adde(int u,int v){
    tot++;
    e[tot].u=u;e[tot].v=v;
    e[tot].nxt=head[u];
    head[u]=tot;
}

void work(int x){
    f[x][1]=a[x];
    int s=0x3f3f3f,p=0;
    for(int i=head[x];i!=-1;i=e[i].nxt){
        int v=e[i].v;
        if(vis[v]==1)continue;
        vis[v]=1;
        work(v);
        f[x][1]+=min(f[v][1],f[v][3]);
        if(f[v][1]<f[v][2]){
            f[x][2]+=f[v][1],p=1;
        }else{
            f[x][2]+=f[v][2],s=min(s,f[v][1]-f[v][2]);
        }
        f[x][3]+=min(f[v][1],f[v][2]);
    }
    if(p==0)f[x][2]+=s;
}

int main(){
    memset(head,-1,sizeof(head));
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int num,val,sum;
        scanf("%d%d%d",&num,&val,&sum);
        a[num]=val;
        for(int j=1;j<=sum;j++){
            int b;
            scanf("%d",&b);
            adde(num,b);adde(b,num);
        }
    }
    vis[1]=1;work(1);
    printf("%d",min(f[1][1],f[1][2]));
}

多叉树转二叉树

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<queue>
#define maxn 3005
using namespace std;

int n,m,a[maxn],root;
int f[maxn][5],vis[maxn];
int lson[maxn],rson[maxn],fa[maxn];

void work(int x)
{
    f[x][1]=a[x];
    int s=0x3f3f3f,p=0;
    for(int i=lson[x];i!=0;i=rson[i]){
        work(i);
        if(f[i][2]<f[i][1]){
            f[x][2]+=f[i][2];s=min(f[i][1]-f[i][2],s);
        }else f[x][2]+=f[i][1],p=1;
        f[x][1]+=min(f[i][3],f[i][1]);
        f[x][3]+=min(f[i][1],f[i][2]);
    }
    if(p==0)f[x][2]+=s;
}

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int num,val,q;
        scanf("%d%d%d",&num,&val,&q);
        a[num]=val;
        for(int j=1;j<=q;j++){
            int s,now=lson[num];
            scanf("%d",&s);
            fa[s]=num;
            if(j==1)lson[num]=s;
            else {
                while(rson[now]!=0){
                    now=rson[now];
                }
                rson[now]=s;
            }
        }
    }
    for(int i=1;i<=n;i++)
     if(fa[i]==0)work(i),root=i;
    printf("%d",min(f[root][1],f[root][2]));
}

提醒一点，多叉树转二叉树需要在执行dp之前跑个O（n）找到根节点