[HDU4729]An Easy Problem for Elfness

[HDU4729]An Easy Problem for Elfness

题目大意：

给你一棵\(n(n\le10^5)\)个点的树，树上每条边都有容量。

\(m(m\le10^5)\)次询问，每次询问你有\(k\)的预算，可以花\(a\)的代价在任意两点间建一条流容量为\(1\)的边（包括重边），或者花费\(b\)的代价将某条边的容量加\(1\)，问在不超过预算的情况下，从\(s\)到\(t\)的最大流量。

思路：

首先，考虑没有\(k,a,b\)的情况，答案就是\(s,t\)路径上的权值最小值\(min\)。

对于\(a\le b\)的情况，由于我们每在\(s\)和\(t\)之间新建一条边都能增加\(1\)的容量，则我们把所有的预算都用来新建边肯定是最优策略。答案是\(min+\lfloor\frac ka\rfloor\)。

对于\(a>b\)的情况，我们有以下两种可能最优的策略：

1. 花费\(a\)的代价新建一条边，然后用剩下的所有预算扩充这条新边的容量。
2. 不断将路径上最小边扩充\(1\)的容量。

对于第一种策略，我们不难得到答案就是\(min+1+\lfloor\frac{k-a}b\rfloor\)。

对于第二种策略，我们可以二分答案\(mid\)。设路径上边容量\(<mid\)的边数有\(c\)个，权值和为\(w\)。则\(c\times mid-w\)就是需要扩充的容量之和。若\(c\times mid-w\le\lfloor\frac kb\rfloor\)，则\(ans>=mid\)，反之\(ans<mid\)。

上文提及的边数与权值和可以用树上主席树方便地求得。

时间复杂度\(\mathcal O(n\log^2n)\)。

源代码：

#include<cstdio>
#include<cctype>
#include<climits>
#include<algorithm>
#include<forward_list>
inline int getint() {
	register char ch;
	while(!isdigit(ch=getchar()));
	register int x=ch^'0';
	while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
	return x;
}
using int64=long long;
constexpr int N=1e5+1,logN=17,logW=15,W=10000;
using Edge=std::pair<int,int>;
std::forward_list<Edge> e[N];
inline void add_edge(const int &u,const int &v,const int &w) {
	e[u].emplace_front((Edge){v,w});
	e[v].emplace_front((Edge){u,w});
}
int n,m,s,t,k,a,b;
class FotileTree {
	#define mid ((b+e)>>1)
	private:
		struct Node {
			int sum;
			int64 val;
			int left,right;
			std::pair<int,int64> operator + (const Node &rhs) const {
				return std::make_pair(sum+rhs.sum,val+rhs.val);
			}
			friend std::pair<int,int64> operator - (const std::pair<int,int64> &lhs,const Node &rhs) {
				return std::make_pair(lhs.first-rhs.sum,lhs.second-rhs.val);
			}
			Node operator * (const int &rhs) const {
				return {sum*rhs,val*rhs};
			}
		};
		Node node[N*logW];
		int sz,new_node(const int &p) {
			node[++sz]=node[p];
			return sz;
		}
	public:
		int root[N];
		void reset() {
			sz=0;
		}
		void insert(int &p,const int &b,const int &e,const int &x) {
			p=new_node(p);
			node[p].sum++;
			node[p].val+=x;
			if(b==e) return;
			if(x<=mid) insert(node[p].left,b,mid,x);
			if(x>mid) insert(node[p].right,mid+1,e,x);
		}
		std::pair<int,int64> query(const int &p,const int &q,const int &r,const int &b,const int &e,const int64 &x) const {
			if(node[p]+node[q]-node[r]*2==std::make_pair(0,0ll)) return std::make_pair(0,0);
			if(x>=e) return node[p]+node[q]-node[r]*2;
			if(x<=mid) {
				return query(node[p].left,node[q].left,node[r].left,b,mid,x);
			} else {
				const auto p1=query(node[p].left,node[q].left,node[r].left,b,mid,x);
				const auto p2=query(node[p].right,node[q].right,node[r].right,mid+1,e,x);
				return std::make_pair(p1.first+p2.first,p1.second+p2.second);
			}
		}
	#undef mid
};
FotileTree tr;
void reset() {
	for(register int i=1;i<=n;i++) e[i].clear();
	tr.reset();
}
inline int lg2(const float &x) {
	return ((unsigned&)x>>23&255)-127;
}
int anc[N][logN],min[N][logN]={{INT_MAX}},dep[N];
void dfs(const int &x,const int &par) {
	anc[x][0]=par;
	dep[x]=dep[par]+1;
	for(register int i=1;i<=lg2(dep[x]);i++) {
		anc[x][i]=anc[anc[x][i-1]][i-1];
		min[x][i]=std::min(min[x][i-1],min[anc[x][i-1]][i-1]);
	}
	for(auto &i:e[x]) {
		const int &y=i.first,&w=i.second;
		if(y==par) continue;
		tr.insert(tr.root[y]=tr.root[x],0,W,min[y][0]=w);
		dfs(y,x);
	}
}
int get_min(int x,int y) {
	if(dep[x]<dep[y]) std::swap(x,y);
	int ret=INT_MAX;
	for(register int i=lg2(dep[x]-dep[y]);i>=0;i--) {
		if(dep[anc[x][i]]>=dep[y]) {
			ret=std::min(ret,min[x][i]);
			x=anc[x][i];
		}
	}
	if(x==y) return ret;
	for(register int i=lg2(dep[x]);i>=0;i--) {
		if(anc[x][i]!=anc[y][i]) {
			ret=std::min(ret,min[x][i]);
			ret=std::min(ret,min[y][i]);
			x=anc[x][i];
			y=anc[y][i];
		}
	}
	ret=std::min(ret,min[x][0]);
	ret=std::min(ret,min[y][0]);
	return ret;
}
inline int get_lca(int x,int y) {
	if(dep[x]<dep[y]) std::swap(x,y);
	for(register int i=lg2(dep[x]-dep[y]);i>=0;i--) {
		if(dep[anc[x][i]]>=dep[y]) {
			x=anc[x][i];
		}
	}
	if(x==y) return x;
	for(register int i=lg2(dep[x]);i>=0;i--) {
		if(anc[x][i]!=anc[y][i]) {
			x=anc[x][i];
			y=anc[y][i];
		}
	}
	return anc[x][0];
}
inline bool check(const int64 &mid) {
	const auto tmp=tr.query(tr.root[s],tr.root[t],tr.root[get_lca(s,t)],0,W,mid);
	return tmp.first*mid-tmp.second<=k/b;
}
int main() {
	const int T=getint();
	for(register int i=1;i<=T;i++) {
		printf("Case #%d:\n",i);
		n=getint(),m=getint();
		for(register int i=1;i<n;i++) {
			const int u=getint(),v=getint(),w=getint();
			add_edge(u,v,w);
		}
		dfs(1,0);
		for(register int i=0;i<m;i++) {
			s=getint(),t=getint(),k=getint(),a=getint(),b=getint();
			const int min=get_min(s,t);
			if(a<=b) {
				printf("%lld\n",min+(int64)k/a);
				continue;
			}
			int64 l=min+(int64)k/a+1,r=min+(int64)k/b;
			while(l<=r) {
				const int64 mid=(l+r)>>1;
				if(check(mid)) {
					l=mid+1;
				} else {
					r=mid-1;
				}
			}
			printf("%lld\n",k>=a?std::max(min+1+(int64)(k-a)/b,l-1):l-1);
		}
		reset();
	}
	return 0;
}