BZOJ4012【动态点分治】

/* I will wait for you*/

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <string>
#define make make_pair
#define fi first
#define se second

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

const int maxn = 200010;
const int maxm = 1010;
const int maxs = 26;
const int inf = 0x3f3f3f3f;
const int P = 1000000007;
const double error = 1e-9;

inline ll read()
{
ll x = 0, f = 1;
char ch = getchar();
while (ch <= 47 || ch >= 58)
f = (ch == 45 ? -1 : 1), ch = getchar();
while (ch >= 48 && ch <= 57)
x = x * 10 + ch - 48, ch = getchar();
return x * f;
}

struct edge
{
ll v, w, next;
} e[2 * maxn];

struct node
{
ll age, seat, pos, dis, pis;
};

bool operator < (node a, node b)
{
return a.age < b.age;
}

ll n, m, ans, cnt, root, sum, A, L, R,
bin[maxn], head[maxn], dis[maxn], fa[maxn][30], deep[maxn],
size[maxn], mx[maxn], fath[maxn], del[maxn], age[maxn];

vector<node> di[maxn];

void insert(int u, ll v, ll w)
{
e[cnt] = (edge) {v, w, head[u]}, head[u] = cnt++;
e[cnt] = (edge) {u, w, head[v]}, head[v] = cnt++;
}

void dfs1(int u)
{
for (int i = head[u]; i != -1; i = e[i].next) {
ll v = e[i].v;
if (v != fa[u][0]) {
deep[v] = deep[u] + 1;
dis[v] = dis[u] + e[i].w;
fa[v][0] = u, dfs1(v);
}
}
}

void init()
{
for (int i = 0; i <= 20; i++)
bin[i] = 1 << i;

for (int i = 1; i <= n; i++)
for (int j = 1; j <= 20; j++)
if (deep[i] >= bin[j])
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}

ll lca(ll u, ll v)
{
if (deep[u] < deep[v])
swap(u, v);

for (int i = 20; i >= 0; i--)
if (deep[u] - bin[i] >= deep[v])
u = fa[u][i];

for (int i = 20; i >= 0; i--)
if (fa[u][i] != fa[v][i])
u = fa[u][i], v = fa[v][i];

return u == v ? u : fa[u][0];
}

ll Dis(int u, int v)
{
int t = (int) lca(u, v);
return dis[u] + dis[v] - 2 * dis[t];
}

void find(int u, int p)
{
size[u] = 1, mx[u] = 0;

for (int i = head[u]; i != -1; i = e[i].next) {
ll v = e[i].v;
if (v != p && !del[v]) {
find(v, u), size[u] += size[v];
mx[u] = max(mx[u], size[v]);
}
}

mx[u] = max(mx[u], sum - size[u]);

if (mx[u] < mx[root])
root = u;
}

void divide(int u, int p)
{
fath[u] = p, del[u] = 1;

di[u].push_back((node) {age[u], u});

for (int i = head[u]; i != -1; i = e[i].next) {
ll v = e[i].v, tmp;
if (v != p && !del[v]) {
root = 0, sum = size[v], find(v, u);
tmp = root, divide(root, u);

for (int j = 0; j < di[tmp].size(); j++) {
node v = di[tmp][j];
node t = (node) {v.age, v.seat};
di[u].push_back(t);
}
}
}

sort(di[u].begin(), di[u].end());

for (int i = 0; i < di[u].size(); i++) {
di[u][i].pos = i + 1;
di[u][i].dis = Dis(u, di[u][i].seat);
di[u][i].pis = Dis(p, di[u][i].seat);
}

for (int i = 1; i < di[u].size(); i++) {
di[u][i].dis += di[u][i - 1].dis;
di[u][i].pis += di[u][i - 1].pis;
}

}

void solve(int u, int p, ll su, ll si)
{
vector<node> :: iterator l
= lower_bound(di[p].begin(), di[p].end(), (node) {L});
vector<node> :: iterator r
= upper_bound(di[p].begin(), di[p].end(), (node) {R});

ll ldis, rdis, lpos, rpos, lpis, rpis;

if (l == di[p].begin())
ldis = lpos = lpis = 0;
else {
l--;
ldis = l -> dis;
lpos = l -> pos;
lpis = l -> pis;
}

if (r == di[p].begin())
rdis = rpos = rpis = 0;
else {
r--;
rdis = r -> dis;
rpos = r -> pos;
rpis = r -> pis;
}

ll size = rpos - lpos;
ll sum = rdis - ldis;
ll pum = rpis - lpis;

ans += (sum - su) + (size - si) * Dis(u, p);

if (fath[p])
solve(u, fath[p], pum, size);
}

int main()
{
n = read(), m = read(), A = read();

for (int i = 1; i <= n; i++)
age[i] = read();

memset(head, -1, sizeof head);
memset(fa, 0, sizeof fa);

for (int i = 1; i < n; i++) {
int u = read(), v = read(), w = read();
insert(u, v, w);
}

dfs1(1), init();

root = 0, sum = n, mx[0] = inf;
find(1, 0), divide(root, 0);

for (int i = 1; i <= m; i++) {
int u = read(), a = read(), b = read();

L = min((a + ans) % A, (b + ans) % A);
R = max((a + ans) % A, (b + ans) % A);

ans = 0, solve(u, u, 0, 0);
printf("%lld\n", ans);
}

return 0;
}