POJ 2152 Fire （树形DP，有趣)

我发现树形DP越来越有趣了……或者说树真的是一个很美妙的数据结构。

【题意】n个节点组成的树，要在树一些点上建立消防站，每个点建站都有个cost[i]，每个点如果不在当前的点上建站，也要依赖其他的消防站，并且距离不超过limit[i]。求符合上述条件的最小费用建站方案。n <= 1000.

【思路】

想了很久没什么想法，状态表示和转移都没什么头绪……发现每个点它能从很多地方获取信息（父亲，爷爷，兄弟，叔叔，子孙）所以显得有点没有办法。但这题的n<=1000，没想到就是直接暴力枚举……

最主要的是维护两个数组：

best[u] ，表示根节点为u的子树满足要求的最小花费是多少，最后的答案就是best[1]

为了求best数组，我们再设一个辅助数组，

dp[u][j]，表示节点u依附于j点时，根节点为u的子树满足要求的最小花费是多少

【状态转移】

best[u] = min(best[u] , dp[u][j]) j是枚举的点。

dp[u][j] =sum of（ min( dp[v][j] - cost[j] , best[v]) ）v是u的孩子。

不是很难理解吧。

这题也是一道十几年的经典老题……也是一道好题，难在思路怎么想，代码实现还是比较简单，代码也短，细节也少，不恶心……

【代码】

/* ***********************************************
Author        :angon

************************************************ */
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
#define showtime fprintf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)
#define lld %I64d
#define REP(i,k,n) for(int i=k;i<n;i++)
#define REPP(i,k,n) for(int i=k;i<=n;i++)
#define scan(d) scanf("%d",&d)
#define scanl(d) scanf("%I64d",&d)
#define scann(n,m) scanf("%d%d",&n,&m)
#define scannl(n,m) scanf("%I64d%I64d",&n,&m)
#define mst(a,k)  memset(a,k,sizeof(a))
#define LL long long
#define N 1005
#define mod 1000000007
inline int read(){int s=0;char ch=getchar();for(; ch<'0'||ch>'9'; ch=getchar());for(; ch>='0'&&ch<='9'; ch=getchar())s=s*10+ch-'0';return s;}

struct Edge
{
    int v,w,next;
}edge[N*2];
int head[N],tot;
void addedge(int u,int v,int w)
{
    edge[tot].v=v; edge[tot].w=w; edge[tot].next=head[u];
    head[u]=tot++;
}
int dp[N][N],best[N],cost[N],limt[N],dis[N][N];
const int INF = 0x3f3f3f3f;
int root,n;
void dfs_dis(int u,int fa,int d) //点root到其他点的距离
{
    dis[root][u] = d;
    for(int i=head[u]; ~i; i=edge[i].next)
    {
        int v = edge[i].v;
        int w = edge[i].w;
        if(v==fa) continue;
        dfs_dis(v,u,d+w);
    }
}

void dfs(int u,int fa)
{
    /*时间复杂度O(n*n),算每个节点复杂度为O(n*k),k=该节点的孩子数；
    所以sum(k)=n,因为每个节点只会被访问一次*/
    for(int i=head[u]; ~i;i=edge[i].next)  //是从叶子节点到根节点DP，所以先递归到叶子节点
    {                                      
        int vv=edge[i].v;   
        if(vv==fa) continue;
        dfs(vv,u);
    }
    for(int j=1;j<=n;j++)
    {
        if(dis[u][j]>limt[u]) continue;
        dp[u][j] = cost[j];
        for(int k=head[u]; ~k; k=edge[k].next) //把子树信息汇总到根节点
        {
            int v=edge[k].v;
            if(v==fa) continue;
            dp[u][j] += min(dp[v][j]-cost[j],best[v]); //依附j点，不依附j点，如果v不能依附j，dp[v][j]=inf
        }
        best[u] = min(best[u] , dp[u][j]);
    }
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int T; scan(T);
    while(T--)
    {
        scan(n);
        REPP(i,1,n) scan(cost[i]);
        REPP(i,1,n) scan(limt[i]);
        mst(dp,INF);mst(best,INF);mst(head,-1);tot=0;
        REP(i,1,n)
        {
            int u,v,w;
            scann(u,v); scan(w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        REPP(i,1,n) dfs_dis(root=i,0,0);//每个点到其他点的距离
        dfs(1,-1);
        printf("%d\n",best[1]);
    }

    return 0;
}