HDU 4313 Matrix 树形dp

题意：

给定n个点的树，m个黑点

以下n-1行给出边和删除这条边的费用

以下m个黑点的点标[0,n-1]

删除一些边使得随意2个黑点都不连通。

问删除的最小花费。

思路：

树形dp

每一个点有2个状态，成为黑点或白点。

若本身这个点就是黑点那么仅仅有黑点一种状态。

否则能够觉得是子树中某个黑点转移上来。

所以dp[i][0]是i点为黑点的状态。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
typedef long long ll;
const ll inf = 1e13;
#define N 100100
struct Edge{
    int to; ll dis; int nex;
    void put(){printf(" (%d,%lld)\n", to, dis);}
}edge[N*2];
int head[N], edgenum;
void init(){memset(head, -1, sizeof head); edgenum = 0 ;}
void add(int u, int v, ll d){
    Edge E = {v, d, head[u]};
    edge[edgenum] = E;
    head[u] = edgenum++;
}
typedef long long ll;
template <class T>
inline bool rd(T &ret) {
    char c; int sgn;
    if(c=getchar(),c==EOF) return 0;
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}
template <class T>
inline void pt(T x) {
    if (x <0) {
        putchar('-');
        x = -x;
    }
    if(x>9) pt(x/10);
    putchar(x%10+'0');
}

int n, black_num;
bool black[N];
ll dp[N][2];
void dfs(int u, int fa){
    ll tmp = 0;
    for(int i = head[u]; ~i; i = edge[i].nex){
        int v = edge[i].to; if(v == fa)continue;
        dfs(v, u);
        tmp += min(dp[v][0] + edge[i].dis, dp[v][1]);
    }
    dp[u][0] = dp[u][1] = inf;
    if(black[u]){
        dp[u][0] = tmp;
    }
    else {
        dp[u][1] = tmp;
        for(int i = head[u]; ~i; i = edge[i].nex){
            int v = edge[i].to; if(v == fa)continue;
            dp[u][0] = min(dp[u][0], dp[v][0] + tmp - min(dp[v][0] + edge[i].dis, dp[v][1]));
        }
    }
}
ll solve(){
    dfs(0, 0);
    if(black[0])
        return dp[0][0];
    else
        return min(dp[0][0], dp[0][1]);
}
void input(){
    init();
    rd(n); rd(black_num);
    ll d;
    for(int i = 1, u, v; i < n; i++)
    {
        rd(u); rd(v); rd(d);
        add(u, v, d);
        add(v, u, d);
    }
    memset(black, 0, sizeof black);
    while(black_num--)
    {
        int u; rd(u);
        black[u] = 1;
    }
}
int main(){
    int T; rd(T);
    while(T--){
        input();
        pt(solve()); putchar('\n');
    }
    return 0;
}
/*
99
16 5
0 1 1
1 2 6
1 3 100
2 4 3
2 5 1
4 12 1
4 6 1
5 8 1
8 13 3
8 15 4
5 7 1
14 7 1
3 9 1
9 10 1
9 11 1
1 3 4 13 15

9 5
0 1 1
0 2 2
2 6  6
1 3 3
1 4 4
1 5 5
4 7 2
1 8 4
8
3
5
6
7

2 2
0 1 1000
1 0

1 0
1 1
1
2 1
0 1 1000
0

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

11 6
0 1 10
0 2 9
0 3 8
0 4 7
1 5 4
2 6 5
3 7 1
3 10 2
3 9 3
4 8 6
5 6 7 9 8 10

ans:
107
10
1000
0
0
0
3
7
12
17

*/