POJ 3659 Cell Phone Network (树dp)

题目链接：http://poj.org/problem?id=3659

给你一个树形图，一个点可以覆盖他周围连接的点，让你用最少的点覆盖所有的点。

dp[i][0]表示用i点来覆盖，dp[i][1]表示用孩子节点来覆盖，dp[i][2]表示用父节点来覆盖

(1) dp[i][0] = min(dp[i.son][0], dp[i.son][1], dp[i.son][2])

(2) dp[i][1] = min(dp[i.son][0], dp[i.son][1]) //特判

(3) dp[i][2] = min(dp[i.son][0], dp[i.son][1])

注意(2)的情况，因为i需要被覆盖，所以dp[i.son][0]至少需要取到一个。

 //#pragma comment(linker, "/STACK:102400000, 102400000")
 #include <algorithm>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <vector>
 #include <cmath>
 #include <ctime>
 #include <list>
 #include <set>
 #include <map>
 using namespace std;
 typedef long long LL;
 typedef pair <int, int> P;
 const int N = 1e4 + ;
 int dp[N][];
 struct Edge {
     int next, to;
 }edge[N << ];
 int head[N], cnt;

 inline void add(int u, int v) {
     edge[cnt].next = head[u];
     edge[cnt].to = v;
     head[u] = cnt++;
 }

 void dfs(int u, int p) {
     dp[u][] = , dp[u][] = dp[u][] = ;
     bool flag = false;
     int Min = ;
     for(int i = head[u]; ~i; i = edge[i].next) {
         int v = edge[i].to;
         if(v == p)
             continue;
         dfs(v, u);
         dp[u][] += min(dp[v][], min(dp[v][], dp[v][]));
         dp[u][] += min(dp[v][], dp[u][]);
         if(dp[v][] <= dp[v][]) {
             flag = true;
             dp[u][] += dp[v][];
         } else {
             dp[u][] += dp[v][];
             Min = min(dp[v][] - dp[v][], Min);
         }
     }
     if(!flag) //要是没取到dp[v][0]
         dp[u][] += Min;
 }

 int main()
 {
     int n, u, v;
     while(~scanf("%d", &n)) {
         memset(head, -, sizeof(head));
         cnt = ;
         for(int i = ; i < n; ++i) {
             scanf("%d %d", &u, &v);
             add(u, v);
             add(v, u);
         }
         dfs(, -);
         printf("%d\n", min(dp[][], dp[][]));
     }
     return ;
 }