【香蕉oi】技能树【hdu6326】Monster Hunter（结论，贪心）

题意

有一棵树，必须先走父亲再走儿子，但是不一定要走完一棵子树再走另一棵子树。每个点有两个权值$a_i,b_i$。

现在你可以拿一个初始权值$T$，按上述方法遍历这棵树，在经过一个节点的时候先减去$a_i$，然后加上$b_i$，要求任意时刻权值大于等于0。

求最小的初始权值。

思路

先考虑没有父亲限制，每个点随时都可以取的情况。

在这道题里节点可以按照$a_i$和$b_i$的一些关系确定谁先取会更优。

首先显然$a_i\le b_i$的肯定优于$a_i>b_i$的。

考虑两个$a_i\le b_i,a_j\le b_j,a_i<a_j$，显然$a$更小的$i$先取更优，因为$a$更小的门槛较低且利于后面的选择。

然后考虑两个$a_i>b_i,a_j>b_j$，我们应该比较$v_i=\max (a_i,a_i+a_j-b_i)$和$v_j=\max (a_j,a_i+a_j-b_j)$的大小，谁的$v$小谁适合放前面。

其实这时候做题已经OK了，但是结论好像还可以再简单一点，所以再做一些没有太大必要的工作。。。

大力分类讨论取$\max$的情况：

（$a_i\ne a_i+a_j-b_i$所以等于的情况不可能存在，在下面为了避免麻烦没有讨论进去。）

1. $\{\begin{array}{r}{a}_i>a_i+a_j-b_i\\ a_j>a_i+a_j-b_j\end{array}$ 即 $\{\begin{array}{r}{a}_j<b_i\\ a_i<b_j\end{array}$ 时，$\{\begin{array}{r}{a}_j<b_i<a_i\\ a_i<b_j<a_j\end{array}$ 自相矛盾，不存在。
2. $\{\begin{array}{r}{a}_i>a_i+a_j-b_i\\ a_j<a_i+a_j-b_j\end{array}$ 即 $b_j<a_j<b_i<a_i$ 时，因为$a_j>b_j$所以$a_i<a_i+a_j-b_j$，所以$i$放在前面一定比$j$更优。
3. $\{\begin{array}{r}{a}_i<a_i+a_j-b_i\\ a_j>a_i+a_j-b_j\end{array}$ 即 $b_i<a_i<b_j<a_j$ 时，因为$a_i>b_i$所以$a_j<a_i+a_j-b_i$，所以$j$放在前面一定比$i$更优。（就是上面那种反一下）
4. $\{\begin{array}{r}{a}_i>a_i+a_j-b_i\\ a_j>a_i+a_j-b_j\end{array}$ 即 $\{\begin{array}{r}{a}_j>b_i\\ a_i>b_j\end{array}$ 时，两式相减发现谁的$b$大谁更优。

由上可知$a_i>b_i,a_j>b_j$时$b_i>b_j$是$i$更优的充分条件。

所以只要比较$b$就行了。真是优美。。。

现在对于任意两个节点，我们已经可以方便的判断他们的优先级大小关系了。然后考虑父亲对儿子的限制。

假如父亲的优先级小于儿子，那么父亲取完儿子必然紧接着要取，所以把儿子并到父亲上面，用并查集维护。最后剩下的就是一棵父亲优先级大于儿子的树，那么把所有节点丢进堆里，一个一个取出来就好了。

好题。

代码

#include
using namespace std;
const int N = 1e5 + 10;
int n, fa[N], faz[N];
vector<int> to[N];
struct node{
	long long a, b;
	int id;
	node(){}
	node(long long _a, long long _b, int _id){
		a = _a; b = _b; id = _id;
	}
	bool operator < (const node &u)const{
		if (a <= b && u.a <= u.b) return a > u.a;
		else if (a <= b && u.a > u.b) return false;
		else if (a > b && u.a <= u.b) return true;
		else if (a > b && u.a > u.b) return b < u.b;
	}
	bool operator != (const node &u)const{
		return a != u.a || b != u.b;
	}
}a[N], ans;
priority_queue<node> que;
bool vis[N];

bool cmp(int x, int y)
{
	return a[x] < a[y];
}

int Find(int x)
{
	if (fa[x] == x) return x;
	return fa[x] = Find(fa[x]);
}

void merge(node &x, node y)
{
	long long a, b;
	a = max(x.a, x.a+y.a-x.b);
	b = a + (-x.a+x.b-y.a+y.b);
	x = node(a, b, x.id);
}

void dfs(int u, int _faz)
{
	fa[u] = u;
	faz[u] = _faz;
	for (int i = 0, sz = to[u].size(); i < sz; ++ i)
		if (to[u][i] != _faz)
			dfs(to[u][i], u);
}

int main()
{
	int T; scanf("%d", &T);
	for (; T--; ){
	        scanf("%d", &n);
	        for (int i = 2; i <= n; ++ i){
		        scanf("%lld%lld", &a[i].a, &a[i].b);
		        a[i].id = i;
		        que.push(a[i]);
	        }
	        for (int i = 1; i <= n; ++ i)
	        	to[i].clear();
	        for (int i = 2; i <= n; ++ i){
		        int x, y;
		        scanf("%d%d", &x, &y);
		        to[x].push_back(y);
		        to[y].push_back(x);
	        }
	        memset(vis, 0, sizeof(vis));
	        dfs(1, 0); vis[1] = 1;
	        ans = node(0, 0, 0);
	        while (!que.empty()){
		        node now = que.top(); que.pop();
		        if (now != a[now.id] || vis[now.id]) continue;
		        int real_fa = Find(faz[now.id]);
		        if (!vis[real_fa]){
			        merge(a[real_fa], now);
			        fa[now.id] = real_fa;
			        que.push(a[real_fa]);
		        }
		        else{
			        vis[now.id] = 1;
			        merge(ans, now);
		        }
	        }
	        printf("%lld\n", ans.a);
	}
	return 0;
}