【uva】1220 Party at Hali-Bula

1. 题目描述
公司里有$n, n \in [1, 200]$个人，他们间的关系构成树状结构。除老板外，每个员工都有唯一一个直属上司，要求从中选择尽量多的人，但是不能同时选择员工和他的直属上司，问最多能选多少人，以及可行解是否是唯一的？

2. 基本思路
这显然又是一个树形DP的题目，经典模型——树的最大独立集。《算法竞赛入门经典》中的典型例题，唯一稍微不同的是需要判断可行解是否唯一。因此，先分析状态：
（1） $dp[u][0]$表示不选$u$的最大人数，$f[u][0]$表示当前选择是否唯一，此时可以选择、也可以不选择$u$的下属；
（2） $dp[u][1]$表示选择$u$的最大人数，$f[u][1]$表示当前选择是否唯一，此时一定不能选择$u$的下属；
可以很容易推导状态转移方程：
\begin{align}
    dp[u][0] &= \sum \max (dp[v][0], dp[v][1])  \\
    f[u][0]  &=  \bigwedge \Big( (dp[v][0] \neq dp[v][1]) \wedge f[v][dp[v][0] < dp[v][1]] \Big) \\
    dp[u][1] &= \sum dp[v][0]   \\
    f[u][1]  &= \bigwedge f[v][0]
\end{align}
可以使用刷表法进行实现这个DP，经典的树形DP模型。

3. 代码

 /* uva1220 */
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <vector>
 #include <deque>
 #include <bitset>
 #include <algorithm>
 #include <cstdio>
 #include <cmath>
 #include <ctime>
 #include <cstring>
 #include <climits>
 #include <cctype>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <iomanip>
 #include <tr1/unordered_map>
 using namespace std;
 //#pragma comment(linker,"/STACK:102400000,1024000")

 #define sti                set<int>
 #define stpii            set<pair<int, int> >
 #define mpii            map<int,int>
 #define vi                vector<int>
 #define pii                pair<int,int>
 #define vpii            vector<pair<int,int> >
 #define rep(i, a, n)     for (int i=a;i<n;++i)
 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 #define clr                clear
 #define pb                 push_back
 #define mp                 make_pair
 #define fir                first
 #define sec                second
 #define all(x)             (x).begin(),(x).end()
 #define SZ(x)             ((int)(x).size())
 #define lson            l, mid, rt<<1
 #define rson            mid+1, r, rt<<1|1
 #define INF                0x3f3f3f3f
 #define mset(a, val)    memset(a, (val), sizeof(a))

 const int maxn = ;
 vi E[maxn];
 int fa[maxn];
 int dp[maxn][];
 bool f[maxn][];
 int n;
 int pid;
 map<string,int> tb;
 map<string,int>::iterator iter;

 void init() {
     rep(i, , n+) {
         E[i].clr();
         fa[i] = ;
     }
     tb.clr();
     pid = ;
     memset(dp, , sizeof(dp));
     memset(f, true, sizeof(f));
 }

 inline void addEdge(int u, int v) {
     fa[v] = u;
     E[u].pb(v);
 }

 inline int findId(const string& s) {
     int ret;

     iter = tb.find(s);
     if (iter == tb.end()) {
         tb[s] = ret = pid++;
     } else {
         ret = iter->sec;
     }

     return ret;
 }

 void dfs(int u) {
     int sz = SZ(E[u]), v;

     dp[u][] = ;
     rep(i, , sz) {
         v = E[u][i];
         dfs(v);
     }

     // choose fa[u] choose u
     dp[fa[u]][] += dp[u][];
     f[fa[u]][] &= f[u][];

     // not choose fa[u], choose or not u
     dp[fa[u]][] += max(dp[u][], dp[u][]);
     f[fa[u]][] &= (dp[u][]!=dp[u][]) & (f[u][dp[u][]<dp[u][]]);
 }

 void solve() {
     dfs();

     if (dp[][] > dp[][])
         printf("%d %s\n", dp[][], f[][]?"Yes":"No");
     else if (dp[][] < dp[][])
         printf("%d %s\n", dp[][], f[][]?"Yes":"No");
     else
         printf("%d No\n", dp[][]);
 }

 int main() {
     ios::sync_with_stdio(false);
     #ifndef ONLINE_JUDGE
         freopen("data.in", "r", stdin);
         freopen("data.out", "w", stdout);
     #endif

     string su, sv;
     int uid, vid;

     while (cin>>n && n) {
         init();
         cin >> su;
         findId(su);
         rep(i, , n) {
             cin >> sv >> su;

             uid = findId(su);
             vid = findId(sv);
             addEdge(uid, vid);
         }
         solve();
     }

     #ifndef ONLINE_JUDGE
         printf("time = %ldms.\n", clock());
     #endif

     return ;
 }