[UVA1205]Color a Tree

题目

传送门 to luogu

思路

堪称绝妙的贪心。显然 $C$ 大的应当先选。但是它有选择要求——父节点已经选了。何解？

答案是，整棵树中 $C$ 最大的一个点，肯定是在其父节点被选择之后，立刻被选择。

$\mathtt{B}\mathtt{r}\mathtt{i}\mathtt{e}\mathtt{f}\mathtt{P}\mathtt{r}\mathtt{o}\mathtt{o}\mathtt{f}:$ 否则可以调整至该方案，更优。

那么我们就用一个新点，表示，连着选择这两个点。但是这个新点的属性是什么呢？

考虑两种顺序，$i,j,k$ 和 $k,i,j$ ，二者的代价进行比较。其实不用列出整个式子，只需要考虑下面一种方案调整为上面的方案的代价：$2c_k-c_i-c_j$ ，我们假设其大于 $0$ 即 $i,j,k$ 更优。那么有

$$\frac{c_i+c_j}{2}<c_k$$

类似地，如果是 $x_1,x_2,x_3,\dots ,x_k$ 必须连着选，那么其与别人比较时，应该赋权值

$$\frac{x_1+x_2+\cdots +x_k}{k}$$

这个权值最小的新点——根据我们的贪心策略——也应该最先拿。

所以我们直接用优先队列维护。注意到 $\frac{a}{b}\le \frac{c}{d}$ 时有

$$\frac{a}{b}\le \frac{a+c}{b+d}\le \frac{c}{d}$$

所以新点的权值比原来的父节点要大。所以第一次访问即是正确情况。复杂度 $\mathcal{O}(n\log n)$ 。

代码

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long int_;
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MaxN = 1005;
struct Node{
	int x, d, id;
	Node(){ }
	Node(int X,int D,int I){
		x = X, d = D, id = I;
	}
	void operator += (const Node &t){
		x += t.x, d += t.d;
	}
	bool operator < (const Node &t) const {
		return 1ll*x*t.d < 1ll*d*t.x;
	}
};
Node node[MaxN], ori[MaxN];
int endpos[MaxN]; // 序列最后一个
priority_queue< Node > pq;

int bro[MaxN]; // 下一个要打的点
int pre[MaxN]; // 父节点

int fa[MaxN];
int findF(int a){
	if(fa[a] != a)
		fa[a] = findF(fa[a]);
	return fa[a];
}

bool vis[MaxN];
int main(){
	int n, rt;
	while(~scanf("%d%d",&n,&rt)){
		if(!n && !rt) break;
		for(int i=1; i<=n; ++i){
			node[i].x = readint();
			node[i].d = 1; // 数量
			node[i].id = i, bro[i] = 0;
			vis[i] = false;
			pq.push(ori[i] = node[i]);
		}
		for(int i=1; i<=n; ++i)
			endpos[i] = fa[i] = i;
		for(int i=1,a; i<n; ++i){
			a = readint();
			pre[readint()] = a;
		}
		
		vis[rt] = true; // 并不需要考虑
		while(!pq.empty()){
			Node t = pq.top(); pq.pop();
			if(vis[t.id]) continue;
			else vis[t.id] = true;
			int sy = findF(pre[t.id]);
			bro[endpos[sy]] = t.id;
			endpos[sy] = endpos[t.id];
			fa[t.id] = sy; // 并查集连接
			node[sy] += node[t.id];
			pq.push(node[sy]); // continue
		}

		int ans = 0;
		for(int i=rt,t=1; i; i=bro[i],++t)
			ans += t*ori[i].x;
		printf("%d\n",ans);
	}
	return 0;
}

拓展

这道题根本就是一道题。我懒得说那么多，看代码注释。

#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
typedef long long int_;
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MaxN = 100005;
struct Node{
	int x, d, id;
	Node(){ }
	Node(int X,int D,int I){
		x = X, d = D, id = I;
	}
	bool operator < (const Node &t) const {
		return 1ll*x*t.d > 1ll*d*t.x;
	}
};
Node node[MaxN], ori[MaxN];
int endpos[MaxN]; // 序列最后一个
priority_queue< Node > pq;

struct Edge{
	int to, nxt;
};
Edge e[MaxN<<1];
int head[MaxN], cntEdge;
void addEdge(int a,int b){
	e[cntEdge].to = b;
	e[cntEdge].nxt = head[a];
	head[a] = cntEdge ++;
}
int dama[MaxN]; // damage 伤害
int bro[MaxN]; // 下一个要打的点

int pre[MaxN]; // 父节点
void dfs(int x){
	for(int i=head[x]; ~i; i=e[i].nxt)
		if(e[i].to != pre[x]){
			pre[e[i].to] = x;
			dfs(e[i].to);
		}
}

int fa[MaxN];
int findF(int a){
	if(fa[a] != a)
		fa[a] = findF(fa[a]);
	return fa[a];
}

bool vis[MaxN];
int main(){
	int n = readint();
	for(int i=1; i<=n; ++i){
		head[i] = -1;
		endpos[i] = i;
		fa[i] = i;
	}
	for(int i=1,a,b; i<n; ++i){
		a = readint(), b = readint();
		addEdge(a,b), addEdge(b,a);
	}
	int_ hp; scanf("%lld",&hp);
	int atk = readint(), def = readint();
	for(int i=2; i<=n; ++i){
		int h = readint();
		dama[i] = readint();
		int d = readint();
		node[i].x = (h-1)/(atk-d);
		node[i].d = readint();
		node[i].id = i;
		pq.push(ori[i] = node[i]);
	}
	dfs(1); // 建树
	while(!pq.empty()){
		Node t = pq.top(); pq.pop();
		if(vis[t.id]) continue;
		vis[t.id] = true; // 已经嗝屁了
		fa[t.id] = findF(pre[t.id]);
		int sy = fa[t.id]; // 父节点
		bro[endpos[sy]] = t.id;
		endpos[sy] = endpos[t.id];
		node[sy].x += node[t.id].x;
		node[sy].d += node[t.id].d;
		if(sy != 1) pq.push(node[sy]);
	}
	int_ hurt = 0;
	for(int i=bro[1]; i; i=bro[i]){
		hurt += 1ll*ori[i].x*(dama[i]-def);
		def += ori[i].d;
	}
	if(hurt >= hp) puts("-1");
	else printf("%lld\n",hp-hurt);
	return 0;
}

/*

做不来……骗分吧。

攻击为 atk 防御为 def 时
打一个怪（攻击 a 防御 d 血量 h）需要
	[ h/(atk-d)上取整-1 ] * (a-def)
的血量消耗，然后 def 增加 r

由于勇士只增加防御，我们直接用“挨刀数”。

d 为蓝宝石数量，x 是挨刀数量。
假设先打 i 再打 j 那么消耗血量为
	x_i * (a_i-def) + x_j * (a_j-def-d_i)
否则是
	x_j * (a_j-def) + x_i * (a_i-def-d_j)
上面小于下面等价于 x_i / d_i < x_j / d_j

所以打完 x_i / d_i 最小的点 t 的父亲之后，应当立即打 t 才是。

此时三个点的顺序有 i,j,k 和 k,i,j 两种。
前者为
	x_i*(a_i-def)+x_j*(a_j-def-d_i)+x_k*(a_k-def-d_i-d_j)
后者为
	x_k*(x_k-def)+x_i*(a_i-def-d_k)+x_j*(a_k-def-d_k-d_i)

二者进行比较，不妨设前者小于后者，那么有
	-x_k*(d_i+d_j) < -x_i*d_k-x_j*d_k
	(x_i+x_j) / (d_i+d_j) < x_k / d_k
所以应当归约到 x'=x_i+x_j, d'=d_i+d_j 的情形！

*/