HDU 4729 An Easy Problem for Elfness（树链剖分 + 二分）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4729

 

题意：给出一棵树，每条边有不同的容量，给出多组询问， 每次询问给出源点，汇点和预算额，可以任意建一条新边其预算为A，或者将某条边扩大1的容量费用为B，问在预算允许范围内S-T的最大流为多少

 

思路：在未进行任何操作时，先算出S-T的最大流，其实是树上瓶颈边的容量cap，如果A <= B，那么只建边即为最优策略，结果就是 cap + K / A

如果A > B，有两种选择，建一条路然后不断在这条路上扩容量，最大流为cap + 1 + (K - A) / B，或者全部用来扩容量即能扩K / B的容量，可以二分答案，然后判断能否将S-T区间的值全部能提到该数值

 

 

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>
#include <string>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

typedef long long ll;

const int maxn = 200010;
const ll inf = INT_MAX;

struct Edge
{
	int to, next;
} edge[maxn << 1];

int head[maxn], tot, val[maxn];
int top[maxn], fa[maxn], deep[maxn];
int num[maxn], p[maxn], fp[maxn];
int son[maxn], pos, mp[maxn];

void init()
{
	tot = 0;
	memset(head, -1, sizeof(head));
	pos = 1;
	memset(son, -1, sizeof(son));
}

void addedge(int u, int v)
{
	edge[tot].to = v;
	edge[tot].next = head[u];
	head[u] = tot++;
}

void dfs1(int u, int pre, int d)
{
	deep[u] = d;
	fa[u] = pre;
	num[u] = 1;
	for (int i = head[u]; i != -1; i = edge[i].next)
	{
		int v = edge[i].to;
		if (v != pre)
		{
			dfs1(v, u, d + 1);
			num[u] += num[v];
			if (son[u] == -1 || num[v] > num[son[u]])
				son[u] = v;
		}
	}
}

void getpos(int u, int sp)
{
	top[u] = sp;
	mp[u] = p[u] = pos++;
	fp[p[u]] = u;
	if (son[u] == -1) return;
	getpos(son[u], sp);
	mp[u] = max(mp[u], mp[son[u]]);
	for (int i = head[u]; i != -1; i = edge[i].next)
	{
		int v = edge[i].to;
		if (v != son[u] && v != fa[u])
			getpos(v, v);
		mp[u] = max(mp[u], mp[v]);
	}
}

ll tr[maxn << 2], sum;

void pushup(int rt)
{
	tr[rt] = min(tr[rt << 1], tr[rt << 1 | 1]);
}

void build(int l, int r, int rt)
{
	if (l == r)
	{
		tr[rt] = inf;
		return ;
	}

	int mid = (l + r) >> 1;
	build(lson);
	build(rson);
	pushup(rt);
}

void update(int p, int c, int l, int r, int rt)
{
	if (l == p && p == r)
	{
		tr[rt] = c;
		return ;
	}

	int mid = (l + r) >> 1;
	if (p <= mid)
		update(p, c, lson);
	else
		update(p, c, rson);
	pushup(rt);
}

ll query(int ql, int qr, int l, int r, int rt)
{
	if (ql <= l && qr >= r)
		return tr[rt];

	ll res = inf;
	int mid = (l + r) >> 1;
	if (ql <= mid)
		res = min(res, query(ql, qr, lson));
	if (qr > mid)
		res = min(res, query(ql, qr, rson));
	return res;
}

bool check(int ql, int qr, ll num, int l, int r, int rt)
{
	if (ql <= l && qr >= r && tr[rt] >= num)
		return true;

	if (l == r)
	{
		if (tr[rt] >= num) return true;
		sum -= num - tr[rt];
		if (sum < 0) return false;
		return true;
	}

	int mid = (l + r) >> 1;
	if (qr <= mid)
		return check(ql, qr, num, lson);
	else if (ql > mid)
		return check(ql, qr, num, rson);
	else
		return check(ql, qr, num, lson) && check(ql, qr, num, rson);
}

bool solve(int u, int v, ll num)
{
	int fu = top[u], fv = top[v];
	while (fu != fv)
	{
		if (deep[fu] < deep[fv])
		{
			swap(fu, fv);
			swap(u, v);
		}
		if (!check(p[fu], p[u], num, 1, pos, 1))
			return false;
		u = fa[fu], fu = top[u];
	}

	if (u == v) return true;
	if (deep[u] > deep[v]) swap(u, v);
	return check(p[son[u]], p[v], num, 1, pos, 1);
}

ll Find(int u, int v)
{
	int fu = top[u], fv = top[v];
	ll res = inf;
	while (fu != fv)
	{
		if (deep[fu] < deep[fv])
		{
			swap(fu, fv);
			swap(u, v);
		}
		res = min(res, query(p[fu], p[u], 1, pos, 1));
		u = fa[fu], fu = top[u];
	}

	if (u == v) return res;
	if (deep[u] > deep[v]) swap(u, v);
	return res = min(res, query(p[son[u]], p[v], 1, pos, 1));
}

int e[maxn][3];

int main()
{
	int t;
	scanf("%d", &t);
	for (int ca = 1; ca <= t; ca++)
	{
		printf("Case #%d:\n", ca);
		init();

		int n, m;
		scanf("%d%d", &n, &m);
		for (int i = 0; i < n - 1; i++)
		{
			int u, v, w;
			scanf("%d%d%d", &u, &v, &w);
			addedge(u, v);
			addedge(v, u);
			e[i][0] = u, e[i][1] = v, e[i][2] = w;
		}

		dfs1(1, 0, 0);
		getpos(1, 1);
		build(1, pos, 1);

		for (int i = 0; i < n - 1; i++)
		{
			if (deep[e[i][0]] > deep[e[i][1]])
				swap(e[i][0], e[i][1]);
			update(p[e[i][1]], e[i][2], 1, pos, 1);
		}

		// for (int i = 1; i <= pos; i++)
		// 	printf("%I64d ", tr[i]);
		// printf("\n");

		for (int i = 0; i < m; i++)
		{
			int S, T, k, a, b;
			scanf("%d%d%d%d%d", &S, &T, &k, &a, &b);

			ll flow = Find(S, T);
			ll ans = flow + k / a;
			if (a <= b)
			{
				printf("%I64d\n", ans);
				continue;
			}

			if (k >= a) ans = max(ans, flow + 1 + (k - a) / b);
			ll l = ans, r = inf, tmp = k / b;
			//	printf("%I64d %I64d %I64d\n", l, r, ans);

			while (l <= r)
			{
				ll mid = (l + r) >> 1;
				sum = tmp;
				if (solve(S, T, mid))
					l = mid + 1, ans = max(ans, mid);
				else
					r = mid - 1;
				//printf("%I64d %I64d %I64d\n", l, r, ans);
			}
			printf("%I64d\n", ans);
		}
	}
	return 0;
}