树形dp——覆盖所有边的最少费用（Protecting Zonk）

一、问题描述

有一个n(n<=10000)个节点的无根树。有两种装置A,B,每种都有无限多个。
1.在某个节点X使用A装置需要C1(C1<=1000)的花费,并且此时与节点X相连的边都被覆盖
2.在某个节点X使用B装置需要C2(C2<=1000)的花费,并且此时与节点X相连的边以及与节点X相连的点相连的边都被覆盖
求覆盖所有边的最小花费

二、问题分析

dp[u][0]:u没有安装装置,且u的子节点下的边都被覆盖
dp[u][1]:u安装装置A
dp[u][2]:u安装装置B
dp[u][3]:u没有安装装置,且v可以不安装装置

dp[u][0]=Sum( min(dp[v][1],dp[v][2]) );
dp[u][1]=min( C1+Sum( min(dp[v][0],dp[v][1],dp[v][2]) ),Sum( min(dp[v][2],dp[v][1],dp[v][0]) 且至少有一个子节点选择B) )
dp[u][2]=C2+Sum( min(dp[v][0],dp[v][1],dp[v][2],dp[v][3]) )
dp[u][3]=Sum(min(dp[v][0],dp[v][1],dp[v][2]))

三、代码实现

 #include<stdio.h>
 #include<iostream>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 using namespace std;

 const int INF = 0x3f3f3f3f;
 const int maxn =  + ;
 struct Edge
 {
     int to, next;
 }e[maxn * ];

 //dp[u][0]:u没有安装装置, 且u的子节点下的边都被覆盖
 //dp[u][1] : u安装装置A
 //dp[u][2] : u安装装置B
 //dp[u][3] : u没有安装装置, 且v可以不安装装置
 int head[maxn], d[maxn][];
 int tot,n,C1,C2;                                                  

 int mostmin(int a, int b, int c)
 {
     return min(a, min(b, c));
 }

 void init()
 {
     tot = ;
     memset(head, -, sizeof(head));
 }

 void addadge(int from, int to)
 {
     e[tot].to = to;
     e[tot].next = head[from];
     head[from] = tot++;
 }

 void dfs(int u, int fa)
 {
     d[u][] = ; d[u][] = C1; d[u][] = C2; d[u][] = ;
     int flag = , sum = , mi = INF;
     for (int i = head[u]; i != -; i = e[i].next)
     {
         int v = e[i].to;
         if (v == fa)    continue;
         dfs(v, u);
         d[u][] += min(d[v][], d[v][]);
         d[u][] += mostmin(d[v][], d[v][], d[v][]);
         d[u][] += min(mostmin(d[v][], d[v][], d[v][]), d[v][]);
         d[u][] += mostmin(d[v][], d[v][], d[v][]);
         int tmp = mostmin(d[v][], d[v][], d[v][]);
         sum += tmp;
         mi = min(mi, d[v][] - tmp);
     }
     sum += mi;
     d[u][] = min(d[u][], sum);
 }

 int main()
 {
     while (scanf("%d%d%d",&n,&C1,&C2) ==  && n)
     {
         init();
         int u, v;

         for (int i = ; i < n - ; i++)
         {
             scanf("%d%d", &u, &v);
             addadge(u, v);
             addadge(v, u);
         }
         dfs(, );
         printf("%d\n", mostmin(d[][], d[][], d[][]));
     }
     return ;
 }