树形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 = 100000 + 10;
struct Edge
{
    int to, next;
}e[maxn * 2];

//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][4]; 
int tot,n,C1,C2;                                                  

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

void init()
{
    tot = 0;
    memset(head, -1, 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][0] = 0; d[u][1] = C1; d[u][2] = C2; d[u][3] = 0;
    int flag = 0, sum = 0, mi = INF;
    for (int i = head[u]; i != -1; i = e[i].next)
    {
        int v = e[i].to;
        if (v == fa)    continue;
        dfs(v, u);
        d[u][0] += min(d[v][1], d[v][2]);
        d[u][1] += mostmin(d[v][0], d[v][1], d[v][2]);
        d[u][2] += min(mostmin(d[v][0], d[v][1], d[v][2]), d[v][3]);
        d[u][3] += mostmin(d[v][0], d[v][1], d[v][2]);
        int tmp = mostmin(d[v][0], d[v][1], d[v][2]);
        sum += tmp;
        mi = min(mi, d[v][2] - tmp);
    }
    sum += mi;
    d[u][1] = min(d[u][1], sum);
}

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

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