例题 9-26 一个调度问题（A Scheduling Problem，UVa1380）

原题链接：https://vjudge.net/problem/UVA-1380
分类：树形DP
备注：树的性质

题意：每次输入是一棵树，其中有有向边和无向边。根据拓扑顺序将树上的点全部消除，也就是入度为0的点才能被消除，问最少需要几步能消除完所有点。同时注意，无向边连接的两个点不能同时被消除。

因此问题可以转化为对每一条无向边选择一个方向来对点进行消除。因为是树的结构，所以答案的范围很特殊。设忽视无向边时的最长有向链的边数为k（边数为节点数-1），那么把无向边定好方向后答案必定是k+1或k+2。

在紫书中是这么做的，从根节点递归，将字节点判断完之后再判断自身。设当前节点为i，字节点以w表示。在保证最长链节边数不超过k的前提下， f(i)表示从后代到i的最长链边数的最小值，g(i)表示从i到后代的最长链边数最小值。

假设后代的f和g都已经指的，那么对于当前节点i，求f(i)需要在f(i)+g(i)<=k的前提下使得f(i)最小。找出所有没定向的后代w，按照f(w)从小到大排序。可以假定选取f值第p小的w定向为w->i，那么如果让f值最小到第p-1小的w也定位w->i，则不会使得f(i)变得更大，而有可能使得g(i)变得更小，而从第p+1小到最大的w定向为i->w，然后可以计算出当前假定状态的g(i)，这里就获得了对一个点所有无向边的定向方案。同样，对于g(w)也可以从小到大排序，得到同样多的定向方案。

如果存在方案使得f(i)+g(i)<=k可以选取，那这个方案就是合法的。然后i的父亲又需要根据i的f值和g值计算新的f和g，那么最好选取的方案是f和g最小的方案。

这里有个疑问：对于节点i要存取的f值和g值可能不能在同一种状态下出现，但就这么保持对f和g的最优也可以获得正确答案是为什么呢？我认为对于i的父节点fa，如果它们之间是无向边，则如果选择fa->i，那么节点fa只能利用到i的g(i)值，如果选择i->fa，则只能利用到i的f(i)值，也就是说父节点不会同时用到子节点的f和g值，那么让用到的那个值是最优的是没有问题的，所以对于特定节点的f和g可以独立地获取最优值，对父节点的计算不会产生影响。

按照上述方式，只要在每个节点都有合法方案，总能找到f(i)+g(i)<=k，那么答案就是k+1，否则答案为k+2

#include <bits/stdc++.h>
using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 205;

struct Edge {
	int u, v, d;
	Edge(int u=0, int v=0, int d=0):u(u), v(v), d(d) {}
};

vector<Edge> e[maxn];
int f[maxn], g[maxn], have_father[maxn], maxlen;
 
int dfs(int u) {
	int ans = 0;
	for (int i = 0; i < e[u].size(); i++) {
		int v = e[u][i].v;
		if (e[u][i].d == 1)
			ans = max(ans, dfs(v) + 1);
	}
	return ans;
}

struct UndirectedSon {
  int w, f, g;
  UndirectedSon(int w=0, int f=0, int g=0):w(w),f(f),g(g){}
};

bool cmp_f(const UndirectedSon& w1, const UndirectedSon& w2) {
  return w1.f < w2.f;
}

bool cmp_g(const UndirectedSon& w1, const UndirectedSon& w2) {
  return w1.g < w2.g;
}

bool dp(int i, int fa) {
	if (e[i].empty()) {
		f[i] = g[i] = 0;
		return true;
	}
	vector<UndirectedSon> sons;
	int f0 = 0, g0 = 0;
	for (int k = 0; k < e[i].size(); k++) {
		int w = e[i][k].v;
		if (w == fa) continue;
		dp(w, i);
		int d = e[i][k].d;
		if (d == 0) sons.push_back(UndirectedSon(w, f[w], g[w]));
		else if (d == 1) g0 = max(g0, g[w] + 1);
		else f0 = max(f0, f[w] + 1);
	}
	if (sons.empty()) {
		f[i] = f0;
		g[i] = g0;
		if (f[i] + g[i] > maxlen) {
			f[i] = g[i] = INF;
		}
		return f[i] < INF;
	}
	
	f[i] = g[i] = INF;
	
	int s = sons.size();
	sort(sons.begin(), sons.end(), cmp_f);
	int maxg[maxn];
	maxg[s-1] = sons[s-1].g;
	for (int k = s-2; k >= 0; k--)
		maxg[k] = max(sons[k].g, maxg[k+1]);
	// f: w->i
	// g: i->w
	for (int p = 0; p <= sons.size(); p++) {
		int ff = f0, gg = g0;
		if (p > 0) ff = max(ff, sons[p-1].f+1);
		if (p < sons.size()) gg = max(gg, maxg[p]+1);
		if (ff + gg <= maxlen) f[i] = min(f[i], ff);
		// 在f[i] + g[i] <= maxlen的前提下，使f[i]尽量小 
	}
	
	sort(sons.begin(), sons.end(), cmp_g);
	int maxf[maxn];
	maxf[s-1] = sons[s-1].f;
	for (int k = s-2; k >= 0; k--)
		maxf[k] = max(sons[k].f, maxf[k+1]);
	for (int p = 0; p <= sons.size(); p++) {
		int ff = f0, gg = g0;
		if (p > 0) gg = max(gg, sons[p-1].g+1);
		if (p < sons.size()) ff = max(ff, maxf[p]+1);
		if (ff + gg <= maxlen) g[i] = min(g[i], gg);
	}
	
	return f[i] < INF;
}

int main(void) {
//	freopen("in.txt", "r", stdin);
	while (true) {
		int u, n = 0;
		scanf("%d", &u);
		if (u == 0) break;
		for (int i = 0; i < maxn; i++) {
			e[i].clear();
			have_father[i] = 0;
		}
		while (true) {
			n = max(n, u);
			int v; 
			char ch;
			while (true) {
				scanf("%d%c", &v, &ch);
				if (v == 0) break;
				have_father[v] = 1;
				n = max(n, v);
				if (ch == 'd') {
					e[u].push_back(Edge(u, v, 1));
					e[v].push_back(Edge(v, u, 2));
				} else if (ch == 'u') {
					e[u].push_back(Edge(u, v, 2));
					e[v].push_back(Edge(v, u, 1));
				}
				else {
					e[u].push_back(Edge(u, v, 0));
				} 
			}
			scanf("%d", &u);
			if (u == 0) break;
		}
		
		int root = 0;
		for (int i = 1; i <= n; i++) {
			if (!have_father[i]) {
				root = i;
				break;
			}
		}
		maxlen = 0;
		for (int i = 1; i <= n; i++)
			maxlen = max(maxlen, dfs(i));
			
		if (dp(root, -1)) printf("%d\n", maxlen + 1);
		else printf("%d\n", maxlen + 2);
	}
	return 0;
}