La idea principal: regalarte un árbol, cada lado tiene una capacidad. Luego, m consultas, cada consulta es independiente entre sí, le dan dos puntos S, T, un presupuesto K,
el costo de construir un nuevo borde con una capacidad de A (se puede construir entre dos nodos cualesquiera, incluidos S, T) , el costo B de aumentar la capacidad de un borde existente en 1.
Pregunte cuál es el flujo máximo de S a T si el presupuesto lo permite.
Esto se divide en dos casos para discutir la solución óptima:
1. Si A ≤ B , Obviamente una nueva construcción no será peor que una expansión, puedes construir kA Tantos lados.
2. Si A > B Hay dos situaciones que pueden ser óptimas; la primera es crear una nueva y luego expandir el borde recién creado; la segunda es expandir el borde en la ruta original; finalmente, la mejor de las dos es la mejor.
Aquí el segundo número máximo de expansiones es kB .
Luego dicotomizamos la respuesta y, si la longitud de la ruta l∗ m i d- ∑aI>kB , Obviamente solo puede ser a n s < m i d ,
De lo contrario es a n s ≥ m i d , ∑aI Es cuestión de utilizar el árbol del presidente + LCA.
/*****************************************
Author :Crazy_AC(JamesQi)
Time :2016
File Name :
*****************************************/
// #pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <map>
#include <set>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <climits>
using namespace std;
#define MEM(x,y) memset(x, y,sizeof x)
#define pk push_back
#define lson rt << 1
#define rson rt << 1 | 1
#define bug cout << "BUG HERE\n"
#define debug(x) cout << #x << " = " << x << endl
#define ALL(v) (v).begin(), (v).end()
#define lowbit(x) ((x)&(-x))
#define Unique(x) sort(ALL(x)); (x).resize(unique(ALL(x)) - (x).begin())
#define BitOne(x) __builtin_popcount(x)
#define showtime printf("time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)
#define Rep(i, l, r) for (int i = l;i <= r;++i)
#define Rrep(i, r, l) for (int i = r;i >= l;--i)
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> ii;
typedef pair<ii,int> iii;
const double eps = 1e-8;
const double pi = 4 * atan(1);
const int inf = 1 << 30;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int nCase = 0;
//?????0???
int dcmp(double x){
if (fabs(x) < eps) return 0;return x < 0?-1:1;}
template<class T> inline bool read(T &n){
T x = 0, tmp = 1;
char c = getchar();
while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if(c == EOF) return false;
if(c == '-') c = getchar(), tmp = -1;
while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
n = x*tmp;
return true;
}
template <class T> inline void write(T n){
if(n < 0){
putchar('-');n = -n;}
int len = 0,data[20];
while(n){data[len++] = n%10;n /= 10;}
if(!len) data[len++] = 0;
while(len--) putchar(data[len]+48);
}
LL QMOD(LL x, LL k) {
LL res = 1LL;
while(k) {
if (k & 1) res = res * x % MOD;k >>= 1;x = x * x % MOD;}
return res;
}
int n, m;
const int maxn = 1e5 + 123;
int head[maxn], nxt[maxn*2], pnt[maxn*2], cap[maxn*2], ecnt;
inline void addedge(int u,int v,int c) {
pnt[ecnt] = v, cap[ecnt] = c, nxt[ecnt] = head[u], head[u] = ecnt++;
pnt[ecnt] = u, cap[ecnt] = c, nxt[ecnt] = head[v], head[v] = ecnt++;
}
struct Query {
int s, t, k, a, b;
void read() { scanf("%d%d%d%d%d", &s, &t, &k, &a, &b); }
}Q[maxn];
struct _LCA {
const static int LOGN = 20;
int dep[maxn], fa[LOGN][maxn];
void dfs(int u,int f, int depth) {
/*u = 1, f = -1, depth = 0*/
fa[0][u] = f, dep[u] = depth;
for (int i = head[u];~i;i = nxt[i]) {
int v = pnt[i];
if (v == f) continue;
dfs(v, u, depth + 1);
}
}
void build(int n) {
for (int k = 0;k < LOGN;++k) {
for (int u = 1;u <= n;++u) {
if (fa[k][u] == -1) fa[k + 1][u] = -1;
else fa[k + 1][u] = fa[k][fa[k][u]];
}
}
}
int upslop(int u,int p) {
for (int k = 0;k < LOGN;++k)
if ((p>>k) & 1) u = fa[k][u];
return u;
}
int LCA(int u,int v) {
if (dep[u] < dep[v]) swap(u, v);
u = upslop(u, dep[u] - dep[v]);
if (u == v) return u;
for (int k = LOGN - 1;k >= 0;--k)
if (fa[k][u] != fa[k][v]) {u = fa[k][u], v = fa[k][v];}
return fa[0][u];
}
}lca;
int root[maxn], ls[maxn*30], rs[maxn*30], tot;
LL sum[maxn*30], _cnt[maxn*20];
void build(int &rt, int l, int r) {
rt = ++tot;
sum[rt] = 0;
_cnt[rt] = 0;
if (l == r) return ;
int mid = (l + r) >> 1;
build(ls[rt], l, mid);
build(rs[rt], mid + 1, r);
}
void updata(int last,int &rt, int l, int r,int pos, int val) {
rt = ++tot;
ls[rt] = ls[last], rs[rt] = rs[last];
sum[rt] = sum[last] + 1, _cnt[rt] = _cnt[last] + val;
if (l == r) return ;
int mid = (l + r) >> 1;
if (pos <= mid) updata(ls[last], ls[rt], l, mid, pos, val);
else updata(rs[last], rs[rt], mid + 1, r, pos, val);
}
void dfs_build(int u,int f, int v) {
updata(root[f], root[u], 0, 10000, v, v);
for (int i = head[u];~i;i = nxt[i]) {
if (pnt[i] == f) continue;
dfs_build(pnt[i], u, cap[i]);
}
}
int Query_Kth (int x, int y, int lca, int l, int r, int k) {
while(l < r) {
int mid = (l + r) >> 1;
/*[l, mid]*/
int temp = sum[ls[x]] + sum[ls[y]] - 2*sum[ls[lca]];
// printf("[l = %d, r = %d, temp = %d]\n", l, r, temp);
// printf("sum_lx = %lld, sum_ly = %lld, sum_l_lca = %lld\n", sum[ls[x]], sum[ls[y]], sum[ls[lca]]);
if (k <= temp) {
x = ls[x], y = ls[y], lca = ls[lca];
r = mid;
}else {
k -= temp;
x = rs[x], y = rs[y], lca = rs[lca];
l = mid + 1;
}
}
return l;
}
int Query(int x, int y,int lca, int l, int r,int cap) {
int ret = 0;
LL cnt = 0, res = 0;
while(l < r) {
int mid = (l + r) >> 1;
/*[l, mid]*/
LL temp_sum = sum[ls[x]] + sum[ls[y]] - 2LL*sum[ls[lca]];
LL temp_cnt = _cnt[ls[x]] + _cnt[ls[y]] - 2LL*_cnt[ls[lca]];
if ((temp_sum + res)*mid - (temp_cnt + cnt) > cap) {
x = ls[x], y = ls[y], lca = ls[lca], r = mid;
}else {
ret = mid;
x = rs[x], y = rs[y], lca = rs[lca];
l = mid + 1;
res += temp_sum;
cnt += temp_cnt;
}
}
return ret;
}
int main(int argc, const char * argv[])
{
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
// ios::sync_with_stdio(false);
// cout.sync_with_stdio(false);
// cin.sync_with_stdio(false);
// cout << (1 << 19) << endl;
int kase;cin >> kase;
while(kase--) {
memset(head, -1, sizeof head), ecnt = tot = 0;
scanf("%d%d", &n, &m);
for (int i = 1, u, v, c;i < n;++i) {
scanf("%d%d%d", &u, &v, &c);
addedge(u, v, c);
}
lca.dfs(1, -1, 0);
lca.build(n);
Rep(i, 1, m) Q[i].read();
build(root[0], 0, 10000);
dfs_build(1, 0, 0);/*u, fa*/
printf("Case #%d:\n", ++nCase);
Rep(i, 1, m) {
// printf("[s = %d, t = %d, lca = %d]\n", Q[i].s, Q[i].t, lca.LCA(Q[i].s, Q[i].t));
LL ans = (LL)Query_Kth(root[Q[i].s], root[Q[i].t], root[lca.LCA(Q[i].s, Q[i].t)], 0, 10000, 1);
// debug(ans);
if (Q[i].a < Q[i].b) ans += Q[i].k / Q[i].a;
else {
if (Q[i].k >= Q[i].a) ans += (Q[i].k - Q[i].a) / Q[i].b + 1;
// debug(ans);
ans = max(ans, (LL)Query(root[Q[i].s], root[Q[i].t], root[lca.LCA(Q[i].s, Q[i].t)], 0, 10000, Q[i].k / Q[i].b));
}
printf("%lld\n", ans);
}
}
// showtime;
return 0;
}