VIJOS-P1144 小胖守皇宫

VIJOS-P1144 小胖守皇宫

Description

huyichen世子事件后，xuzhenyi成了皇上特聘的御前一品侍卫。 皇宫以午门为起点，直到后宫嫔妃们的寝宫，呈一棵树的形状；某些宫殿间可以互相望见。大内保卫森严，三步一岗，五步一哨，每个宫殿都要有人全天候看守，在不同的宫殿安排看守所需的费用不同。 可是xuzhenyi手上的经费不足，无论如何也没法在每个宫殿都安置留守侍卫。 帮助xuzhenyi布置侍卫，在看守全部宫殿的前提下，使得花费的经费最少。

Input

输入文件中数据表示一棵树，描述如下： 第1行 n，表示树中结点的数目。 第2行至第n+1行，每行描述每个宫殿结点信息，依次为：该宫殿结点标号i（0< i< =n），在该宫殿安置侍卫所需的经费k，该边的儿子数m，接下来m个数，分别是这个节点的m个儿子的标号r1，r2，…，rm。 对于一个n（0 < n < = 1500）个结点的树，结点标号在1到n之间，且标号不重复。

Output

输出文件仅包含一个数，为所求的最少的经费。

Sample Input

6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0

Sample Output

25

HINT

---

树形DP

Solution:

我承认自己逻辑蒻。。
首先要明确状态：
dp[i][0]:自己守卫
dp[i][1]:被儿子守
dp[i][2]:被父亲守
然后对于每种状态分析转移方程:

1. dp[i][0]:自己守卫
   ：对于自己守卫自己的情况，儿子节点(v)的三种状态都可能
   ->dp[u][0]+=min(dp[v][2],min(dp[v][0],dp[v][1]));

2. dp[i][2]:被父亲守
   :这种情况也比较容易理解，即对于每个儿子来说，它既可以自己守也可以被儿子的儿子守。为什么这时候不再需要被父节点守呢？这是因为如果父节点也守那么这个点就不再需要被它的父节点守了。
   ->dp[u][2]+=min(dp[v][1],dp[v][0]);

3. dp[i][1]:被儿子守
   :这种情况就相对复杂了一些。
   如果点u被自己的儿子守，那么就意味着u的所有子节点中至少有一个点需要自己守自己。那么什么情况下u的子节点不会选择守呢？对于子节点v来说，自己守的代价为dp[v][0],而因为它的父节点u不会守自己，所以v还有一种选择，也就是被自己的儿子守，即dp[v][1];所以当dp[v][0]>dp[v][1]时，v不会守。
   · 同时需要注意此时的dp[u][2]表示的是所有子节点的最小总价值，dp[u][2]-min(dp[v][1],dp[v][0])+dp[v][0] 表示的就是如果u点被儿子守，所有儿子中至少有一个点守的价值。然后在其中取最小值。
   ->dp[u][1]=min(dp[u][1],dp[u][2]-min(dp[v][1],dp[v][0])+dp[v][0]
   Code:

#include <stdio.h>
#include <string.h>
#define MAXN 2000
#define INF 999999
struct node
{
    int from;
    int to;
    int next; 
}edge[MAXN];
int n,pos,m,r,k,cnt,ans,t;
int head[MAXN],val[MAXN],in[MAXN],dp[MAXN][3];
int min(int a,int b){return a<b?a:b;}
void init()
{
    memset(head,-1,sizeof(head));
    cnt=1;
}
void addedge(int from,int to)
{
    edge[cnt].from=from;
    edge[cnt].to=to;
    edge[cnt].next=head[from];
    head[from]=cnt++;
}
void dfs(int u)
{
    dp[u][0]=val[u];
    dp[u][1]=INF;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        dfs(v);
        dp[u][0]+=min(dp[v][2],min(dp[v][0],dp[v][1]));
        dp[u][2]+=min(dp[v][1],dp[v][0]); 
    }
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        dp[u][1]=min(dp[u][1],dp[u][2]-min(dp[v][1],dp[v][0])+dp[v][0]);
    }
}
int main()
{
    init();
    scanf("%d",&n);
    int t=n;
    while(t--)
    {
        scanf("%d",&pos);
        scanf("%d%d",&val[pos],&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&r);
            addedge(pos,r);
            in[r]++;
        }       
    }       
    for(int i=1;i<=n;i++)
    {
        if(!in[i])
        {
            dfs(i);
            printf("%d\n",min(dp[i][0],dp[i][1]));
            return 0;
        }
    }    
    return 0;
}