【树链剖分】 HDU 4729 An Easy Problem for Elfness 二分

点击打开链接

给出一棵树 每条边有容量

新建一条边(初始值为1) 需要A$ 

容量增加1 需要B$

询问  预算有K 使得S->T的流量最大

分三种情况

1. A<=B时  为S->T路径上最小值+K/A;

2. A > B时 新建一条边再扩容该条边  

3. 扩容 S->T路径上的边 使得最小值最大

1和2可以很快的算出

对于第3种情况我们可以二分答案 求解

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
#include <queue>
#include <stack>
#include <vector>
#include <deque>
#include <set>
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <map>
typedef long long LL;
const int MAXN = 101000;//点数的最大值
const int MAXM = 604000;//边数的最大值
const LL INF = 1152921504;
const LL mod= 258280327;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int read()
{
char ch=' ';
int ans=0;
while(ch<'0' || ch>'9')
ch=getchar();
while(ch<='9' && ch>='0')
{
ans=ans*10+ch-'0';
ch=getchar();
}
return ans;
}
struct EDGENODE{
int to;
int w;
int next;
}edges[MAXM];
int head[MAXN],edge;
inline void init(){
edge=0;
memset(head,-1,sizeof(head));
}
inline void addedge(int u,int v,int w){
edges[edge].w=w,edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;
edges[edge].w=w,edges[edge].to=u,edges[edge].next=head[v],head[v]=edge++;
}
int que[MAXN]; // 队列
bool vis[MAXN]; // 访问标记
int son[MAXN]; // 重儿子
int idx[MAXN]; // 结点v在其路径中的编号
int dep[MAXN]; // 结点v的深度
int siz[MAXN]; // 以结点v为根的子树的结点个数
int belong[MAXN]; // 结点v所属的路径编号
int fa[MAXN]; // 结点v的父亲结点
int top[MAXN]; // 编号为p的路径的顶端结点
int len[MAXN]; // 路径p的长度
int sump[MAXN]; // 路径p的编号
int seg[MAXN]; // 结点v的父边在线段树中的位置
int wei[MAXN]; // 结点v的父边的权值
int l,r,ans,cnt;
int n;
char cmd[22];
int num[MAXN];
void split(){
memset(dep,-1,sizeof(dep));
l=0;
dep[ que[r=1]=1 ]=0; // 将根结点插入队列，并设深度为0
fa[1]=-1; // 默认 1 为根结点
wei[1]=0;
while (l<r){ // 第一遍搜索求出 fa,dep,wei
int u=que[++l];
vis[u]=false; // 顺便初始化vis
for (int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].to;
int w=edges[i].w;
if (dep[v]==-1){ // 未访问过的结点
dep[ que[++r]=v ]=dep[u]+1; // 将v插入队列并设深度为dep[u]+1
fa[v]=u; // v的父结点为u
wei[v]=w; // v的父边权值
}
}
}
cnt=0; // 重链编号
for (int i=n;i>0;i--){
int u=que[i],p=-1;
siz[u]=1;
son[u]=p;
for (int k=head[u];k!=-1;k=edges[k].next){
int v=edges[k].to;
if (vis[v]){ // 若v是u的子结点
siz[u]+=siz[v]; // 计数
if (p==-1||siz[v]>siz[p]){
son[u]=v;
p=v; // u的重儿子是v
}
}
}
if (p==-1){ // u是叶子结点
idx[u]=len[++cnt]=1; // 一个新的路径编号为cnt，u是路径中的第一个结点
belong[ top[cnt]=u ]=cnt; // u是顶端结点，且u属于路径cnt
}
else{ // u不是叶子结点
idx[u]=++len[ belong[u]=belong[p] ]; // u属于重儿子所在的链，链长+1，u是路径中第len个结点
top[ belong[u] ]=u; // u是顶端结点
}
vis[u]=true; // 访问标记
}
}
struct tree
{
LL sum[MAXN<<2];
LL have;
void pushup(int rt)
{
sum[rt]=min(sum[rt<<1],sum[rt<<1|1]);
}
void build(int l,int r,int rt)
{
if(l==r)
{
sum[rt]=num[l];
return ;
}
int m=(l+r)>>1;
build(lson);
build(rson);
pushup(rt);
}
LL query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
{
return sum[rt];
}
int m=(l+r)>>1;
LL ans=INF;
if(L<=m)
ans=min(ans,query(L,R,lson));
if(R>m)
ans=min(ans,query(L,R,rson));
return ans;
}
bool yes(LL val,int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R&&sum[rt]>=val)
return true;
if(l==r)
{
if(sum[rt]>=val)
return true;
have-=(val-sum[rt]);
if(have>=0)
return true;
else
return false;
}
int m=(l+r)>>1;
bool g1=true,g2=true;
if(L<=m)
g1=yes(val,L,R,lson);
if(m<R)
g2=yes(val,L,R,rson);
return g1&&g2;
}
}xixixi;
LL find(int va,int vb){
int f1=top[belong[va]],f2=top[belong[vb]];
LL tmp=INF;
while (f1!=f2){
if (dep[f1]<dep[f2]){
swap(f1,f2);
swap(va,vb);
}
tmp=min(tmp,xixixi.query(seg[f1],seg[va],1,n,1));
va=fa[f1];
f1=top[belong[va]];
}
if (va==vb) return tmp;
if (dep[va]>dep[vb]) swap(va,vb);
return min(tmp,xixixi.query(seg[son[va]],seg[vb],1,n,1));
}
bool gao(LL x,int va,int vb)
{
int f1=top[belong[va]],f2=top[belong[vb]];
while (f1!=f2){
if (dep[f1]<dep[f2]){
swap(f1,f2);
swap(va,vb);
}
if(!xixixi.yes(x,seg[f1],seg[va],1,n,1))
return false;
va=fa[f1];
f1=top[belong[va]];
}
if (va==vb) return true;
if (dep[va]>dep[vb]) swap(va,vb);
if(!xixixi.yes(x,seg[son[va]],seg[vb],1,n,1))
return false;
return true;

}
int main()
{
int m,cas=0;
int t;
scanf("%d",&t);
while (t--)
{
cin>>n>>m;
init();
int x,y,a,b,k,c;
for (int i=1;i<n;i++){
scanf("%d%d%d",&a,&b,&c);
// a=read(),b=read(),c=read();
addedge(a,b,c);
}
split();
sump[0]=0;
for (int i=1;i<=cnt;i++) sump[i]=sump[i-1]+len[i];
for (int i=1;i<=n;i++){
seg[i]=sump[ belong[i] ]-idx[i]+1;
num[ seg[i] ]=wei[i];
}
xixixi.build(1,n,1);
printf("Case #%d:\n",++cas);
while (m--)
{
// x=read(),y=read(),k=read(),a=read(),b=read();
scanf("%d%d%d%d%d",&x,&y,&k,&a,&b);
LL ans=find(x,y);
if(a<=b)
printf("%I64d\n",ans+k/a);
else
{
LL now=(LL)k/b,hh=ans,out=0;
if(k>=a)
hh=ans+(k-a)/b+1;
LL ll=hh,rr=max(hh,ans+now);
while(ll<=rr)
{
LL mm=(ll+rr)>>1;
xixixi.have=now;
if(gao(mm,x,y))
{
out=mm;
ll=mm+1;
}
else rr=mm-1;
}
printf("%I64d\n",max(hh,out));
}
}
}
return 0;
}