[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\)的情况，我们有以下两种可能最优的策略：
- 花费\(a\)的代价新建一条边，然后用剩下的所有预算扩充这条新边的容量。
- 不断将路径上最小边扩充\(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;
}
