POJ 2152 fire / SCU 2977 fire（树型动态规划）

POJ 2152 fire / SCU 2977 fire（树型动态规划）

Description

Country Z has N cities, which are numbered from 1 to N. Cities are connected by highways, and there is exact one path between two different cities. Recently country Z often caught fire, so the government decided to build some firehouses in some cities. Build a firehouse in city K cost W(K). W for different cities may be different. If there is not firehouse in city K, the distance between it and the nearest city which has a firehouse, can’t be more than D(K). D for different cities also may be different. To save money, the government wants you to calculate the minimum cost to build firehouses.

Input

The first line of input contains a single integer T representing the number of test cases. The following T blocks each represents a test case.

The first line of each block contains an integer N (1 < N <= 1000). The second line contains N numbers separated by one or more blanks. The I-th number means W(I) (0 < W(I) <= 10000). The third line contains N numbers separated by one or more blanks. The I-th number means D(I) (0 <= D(I) <= 10000). The following N-1 lines each contains three integers u, v, L (1 <= u, v <= N，0 < L <= 1000), which means there is a highway between city u and v of length L.

Output

For each test case output the minimum cost on a single line.

Sample Input

5
5
1 1 1 1 1
1 1 1 1 1
1 2 1
2 3 1
3 4 1
4 5 1
5
1 1 1 1 1
2 1 1 1 2
1 2 1
2 3 1
3 4 1
4 5 1
5
1 1 3 1 1
2 1 1 1 2
1 2 1
2 3 1
3 4 1
4 5 1
4
2 1 1 1
3 4 3 2
1 2 3
1 3 3
1 4 2
4
4 1 1 1
3 4 3 2
1 2 3
1 3 3
1 4 2

Sample Output

2
1
2
2
3

Http

POJ:https://vjudge.net/problem/POJ-2152
SCU:https://vjudge.net/problem/SCU-2977

Source

树型动态规划

题目大意

n个城市由n-1条带权的路相连接，现在要选择一些城市建造消防站，每个城市建造消防站都有不同的花费，并且要满足没有建消防站的城市u在D[u]范围内有建了消防站的城市（每个城市的D[u]也有可能不一样），现在求花费最小的方案。

解决思路

看到这个题目的第一眼想到的是最小支配集，但要注意题中在D[u]范围内这个条件，我们不能用简单的最小支配集算法来解决。

在开始讲述前，我们先规定几个变量及其意义。

F[u][build]：这是我们动态规划的数组，其意义是选择在build处修建消防站来覆盖u的最小花费（并保证此时u的所有子树都已经被覆盖）

Best[u]：表示覆盖u的所有方案中花费最小的一个

Dist[u][v]：u和v之间的距离

首先我们来看稍微好理解一点的Best[u]，根据定义，对于所有的满足Dist[u][build]< D[u]的我们可以得到Best[u]=min(Best[u],Dist[u][build])。这是可以直接根据定义推导出来的。

那么接下来就是求F[u][build]啦。

当然首先是要递归地求出u的子节点（下文中均用v来表示）的信息。

接下来就是最重要的部分了，有点难理解，仔细阅读！
然后我们枚举图中的每一个点build，表示在build建消防站来覆盖点u。若Dist[u][build]>D[u]，说明在build建立消防站不能覆盖点u，那么我们就把F[u][build]置为无穷大。若Dist[u][build]< D[u]，说明可以在build建立消防站来覆盖点u，我们就依次枚举u的子节点v，让F[u][build]每次累加min(Best[v],F[v][build]-W[build]），最后再让F[u][build]加上建站在build的费用W[build]。下面来解释一下这个转移是如何进行的，又是基于什么原理。

因为在build建立消防站后可能不止覆盖到u，还有可能同时可以覆盖u的子节点v，那么此时v就有两种选择，一是被build覆盖（即上面的F[v][build]-W[build]，你问我为什么要减去W[build]，因为F[v][build]中是统计了建站在build时的费用的，为了防止重复计算建立消防站在build的费用，所以这里要减去）；二是被其他点覆盖（即上面的Best[v]）。

另外如果build无法覆盖v怎么办（即Dist[v][build]>D[v]），上面的方程好像没有考虑到这种情况啊？
不用担心，若build无法覆盖v，此时的F[v][build]是置为无穷大的，取min后不会被统计到F[u][build]中。

最后，为了节省空间，在笔者的代码中，Dist转换成了一维的，Dist[v]表示当前dfs中的点u到v的距离。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

const int maxN=1001;
const int inf=2147483647;

class Edge
{
public:
    int v,w;
};

int n;
int W[maxN];
int D[maxN];
vector<Edge> E[maxN];
int Dist[maxN];
int F[maxN][maxN];
int Best[maxN];
queue<int> Q;

int read();
void dfs(int u,int father);

int main()
{
    int TT;
    TT=read();
    for (int ti=1;ti<=TT;ti++)
    {
        n=read();
        for (int i=1;i<=n;i++)//注意多组数据记得清空
            E[i].clear();
        for (int i=1;i<=n;i++)
            W[i]=read();
        for (int i=1;i<=n;i++)
            D[i]=read();
        for (int i=1;i<n;i++)
        {
            int x=read(),y=read(),w=read();
            E[x].push_back((Edge){y,w});
            E[y].push_back((Edge){x,w});
        }
        //cout<<"Read_end"<<endl;
        dfs(1,1);
        cout<<Best[1]<<endl;
    }
    return 0;
}

int read()
{
    int x=0;
    int k=1;
    char ch=getchar();
    while (((ch<'0')||(ch>'9'))&&(ch!='-'))
        ch=getchar();
    if (ch=='-')
    {
        k=-1;
        ch=getchar();
    }
    while ((ch>='0')&&(ch<='9'))
    {
        x=x*10+ch-48;
        ch=getchar();
    }
    return x*k;
}

void dfs(int u,int father)
{
    for (int i=0;i<E[u].size();i++)//首先把所有子节点的值算出来
    {
        int v=E[u][i].v;
        if (v==father)
            continue;
        dfs(v,u);
    }
    memset(Dist,-1,sizeof(Dist));//临时用bfs求出u到所有点的距离
    while (!Q.empty())
        Q.pop();
    Dist[u]=0;
    Q.push(u);
    do
    {
        int uu=Q.front();
        Q.pop();
        for (int i=0;i<E[uu].size();i++)
        {
            int v=E[uu][i].v;
            if (Dist[v]==-1)
            {
                Dist[v]=Dist[uu]+E[uu][i].w;
                Q.push(v);
            }
        }
    }
    while (!Q.empty());
    Best[u]=inf;//因为要求最小，所以初值为无穷大
    for (int build=1;build<=n;build++)
    {
        if (Dist[build]<=D[u])
        {
            F[u][build]=W[build];
            for (int i=0;i<E[u].size();i++)
            {
                int v=E[u][i].v;
                if (v==father)
                    continue;
                F[u][build]+=min(Best[v],F[v][build]-W[build]);//统计u的子节点v
            }
            Best[u]=min(Best[u],F[u][build]);//用刚计算出来的F[u][build]更新Best[u]
        }
        else//若build无法覆盖u，则置为无穷大
            F[u][build]=inf;
    }
    return;
}