[HNOI 2015]开店

Description

风见幽香有一个好朋友叫八云紫，她们经常一起看星星看月亮从诗词歌赋谈到

人生哲学。最近她们灵机一动，打算在幻想乡开一家小店来做生意赚点钱。这样的

想法当然非常好啦，但是她们也发现她们面临着一个问题，那就是店开在哪里，面

向什么样的人群。很神奇的是，幻想乡的地图是一个树形结构，幻想乡一共有 n

个地方，编号为 1 到 n，被 n-1 条带权的边连接起来。每个地方都住着一个妖怪，

其中第 i 个地方的妖怪年龄是 x_i。妖怪都是些比较喜欢安静的家伙，所以它们并

不希望和很多妖怪相邻。所以这个树所有顶点的度数都小于或等于 3。妖怪和人一

样，兴趣点随着年龄的变化自然就会变化，比如我们的 18 岁少女幽香和八云紫就

比较喜欢可爱的东西。幽香通过研究发现，基本上妖怪的兴趣只跟年龄有关，所以

幽香打算选择一个地方 u（u为编号），然后在 u开一家面向年龄在 L到R 之间（即

年龄大于等于 L、小于等于 R）的妖怪的店。也有可能 u这个地方离这些妖怪比较

远，于是幽香就想要知道所有年龄在 L 到 R 之间的妖怪，到点 u 的距离的和是多

少（妖怪到 u 的距离是该妖怪所在地方到 u 的路径上的边的权之和） ，幽香把这个

称为这个开店方案的方便值。幽香她们还没有决定要把店开在哪里，八云紫倒是准

备了很多方案，于是幽香想要知道，对于每个方案，方便值是多少呢。

Input

第一行三个用空格分开的数 n、Q和A，表示树的大小、开店的方案个数和妖

怪的年龄上限。 

第二行n个用空格分开的数 x_1、x_2、…、x_n，x_i 表示第i 个地点妖怪的年

龄，满足0<=x_i<A。(年龄是可以为 0的，例如刚出生的妖怪的年龄为 0。) 

接下来 n-1 行，每行三个用空格分开的数 a、b、c，表示树上的顶点 a 和 b 之

间有一条权为c(1 <= c <= 1000)的边，a和b 是顶点编号。 

接下来Q行，每行三个用空格分开的数 u、 a、 b。对于这 Q行的每一行，用 a、

b、A计算出 L和R，表示询问“在地方 u开店，面向妖怪的年龄区间为[L,R]的方

案的方便值是多少”。对于其中第 1 行，L 和 R 的计算方法为：L=min(a%A,b%A), 

R=max(a%A,b%A)。对于第 2到第 Q行，假设前一行得到的方便值为 ans，那么当

前行的 L 和 R 计算方法为： L=min((a+ans)%A,(b+ans)%A), 

R=max((a+ans)%A,(b+ans)%A)。 

Output

对于每个方案，输出一行表示方便值。

Sample Input

10 10 10
0 0 7 2 1 4 7 7 7 9
1 2 270
2 3 217
1 4 326
2 5 361
4 6 116
3 7 38
1 8 800
6 9 210
7 10 278
8 9 8
2 8 0
9 3 1
8 0 8
4 2 7
9 7 3
4 7 0
2 2 7
3 2 1
2 3 4

Sample Output

1603
957
7161
9466
3232
5223
1879
1669
1282
0

HINT

满足 n<=150000,Q<=200000。对于所有数据，满足 A<=10^9

题解

若 $u,v$ 在一棵树上，显然存在 $$dist_{u, v} = dist_{root, u}+dist_{root, v}-2*dist_{root, lca(u, v)}$$

其中 $dist_{u, v}$ 表示树上 $u<->v$ 之间的路径长度。

而对于此题，显然每组询问 $[L, R]$ 的答案，就是（记点权在集合 $[L, R]$ 中的点为点集 $S$ ）：

$$ans = \sum_{v \in S} (dist_{root, u}+dist_{root, v}-2*dist_{root, lca(u, v)})$$
$$= |S|*dist_{root, u}+\sum_{v \in S}dist_{root, v}-2*\sum_{v \in S}dist_{root, lca(u, v)}$$

注意到 $|S|*dist_{root, u}$ 可以直接求；我们按每个点的点权排序，显然 $\sum_{v \in S}dist_{root, v}$ 是可以用前缀和预处理出来的。

现在需要解决的问题就是如何求 $\sum_{v \in S}dist_{root, lca(u, v)}$ 。

我们注意到这样一个事情：对于求 $dist_{root, lca(u, v)}$ ，我们可以先将 $root<->u$ 的路径上的边标记；再询问 $root<->v$ 的边，询问到的有标记边的就是 $root<->lca(u, v)$ 上的边。

对于这个方法，我们可以将按点权排序后的点，按序存到主席树中。询问 $[L, R]$ 就是询问 $[1, R]-[1, L-1]$ 。

实现方面，值得注意的是，对于新建的主席树，因为树剖每次会修改可能不止一个区间，所以在这个版本下新建的节点可以修改，我们记录一个数组 $pre_i$ 表示第 $i$ 个版本（及之前）动态开点开的最大的值。新建节点时，若当前节点 $o > pre$ 即 $o$ 是当前版本才新建的，所以可以直接修改。

询问的时候，若有 $lazy$ 标记，我是直接暴力下放的，不知道有没有更好的方法。

 //It is made by Awson on 2018.1.1
 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 using namespace std;
 const int N = ;
 const int M = N*;
 const int INF = ~0u>>;

 int n, q, a, u, v, c, x1, x2;
 struct tt {
     int to, next, cost;
 }edge[(N<<)+];
 int path[N+], tot;
 struct value {
     int x, id;
     bool operator < (const value &b) const {
     return x < b.x;
     }
 }w[N+];
 int size[N+], son[N+], sonc[N+], fa[N+], dep[N+], pos[N+], top[N+], cnt;
 LL val[N+], dist[N+], sumdist[N+];
 struct Segment_tree {
     int root[N+], pre[N+], lazy[M+], ch[M+][], pos;
     LL sum[M+];
     void pushdown(int o, int l, int mid, int r, int last) {
         if (ch[o][] <= last) {
         int ls = ch[o][]; ch[o][] = ++pos;
         lazy[ch[o][]] = lazy[ls], ch[ch[o][]][] = ch[ls][], ch[ch[o][]][] = ch[ls][], sum[ch[o][]] = sum[ls];
     }
     if (ch[o][] <= last) {
         int rs = ch[o][]; ch[o][] = ++pos;
         lazy[ch[o][]] = lazy[rs], ch[ch[o][]][] = ch[rs][], ch[ch[o][]][] = ch[rs][], sum[ch[o][]] = sum[rs];
     }
         sum[ch[o][]] += (val[mid]-val[l-])*lazy[o], sum[ch[o][]] += (val[r]-val[mid])*lazy[o];
         lazy[ch[o][]] += lazy[o], lazy[ch[o][]] += lazy[o], lazy[o] = ;
     }
     void update(int &o, int l, int r, int a, int b, int last) {
     if (o <= last) {
         int rt = o; o = ++pos;
         lazy[o] = lazy[rt], ch[o][] = ch[rt][], ch[o][] = ch[rt][], sum[o] = sum[rt];
     }
         if (a <= l && r <= b) {
             lazy[o] += , sum[o] += val[r]-val[l-];
         return;
         }
         int mid = (l+r)>>;
         if (lazy[o]) pushdown(o, l, mid, r, last);
         if (mid >= a) update(ch[o][], l, mid, a, b, last);
         if (mid < b) update(ch[o][], mid+, r, a, b, last);
     sum[o] = sum[ch[o][]]+sum[ch[o][]];
     }
     LL query(int o, int l, int r, int a, int b) {
     if (a <= l && r <= b) return sum[o];
     int mid = (l+r)>>; LL c1 = , c2 = ;
     if (lazy[o]) pushdown(o, l, mid, r, INF);
     if (mid >= a) c1 = query(ch[o][], l, mid, a, b);
     if (mid < b) c2 = query(ch[o][], mid+, r, a, b);
     return c1+c2;
     }
 }T;

 void add(int u, int v, int c) {
     edge[++tot].to = v;
     edge[tot].cost = c;
     edge[tot].next = path[u];
     path[u] = tot;
 }
 void dfs1(int u, int father, int depth) {
     size[u] = , fa[u] = father, dep[u] = depth;
     for (int i = path[u]; i; i = edge[i].next)
     if (edge[i].to != father) {
         dfs1(edge[i].to, u, depth+);
         size[u] += size[edge[i].to];
         if (size[edge[i].to] > size[son[u]]) son[u] = edge[i].to, sonc[u] = edge[i].cost;
     }
 }
 void dfs2(int u, int tp, int cost) {
     top[u] = tp, pos[u] = ++cnt, val[cnt] = cost;
     if (son[u]) {
     dist[son[u]] = dist[u]+sonc[u];
     dfs2(son[u], tp, sonc[u]);
     }
     for (int i = path[u]; i; i = edge[i].next)
     if (edge[i].to != fa[u] && edge[i].to != son[u]) {
         dist[edge[i].to] = dist[u]+edge[i].cost;
         dfs2(edge[i].to, edge[i].to, edge[i].cost);
     }
 }
 void lca_update(int &o, int x, int last) {
     while (x) {
     T.update(o, , n, pos[top[x]], pos[x], last);
     x = fa[top[x]];
     }
 }
 LL lca_query(int o, int x) {
     LL ans = ;
     while (x) {
     ans += T.query(o, , n, pos[top[x]], pos[x]);
     x = fa[top[x]];
     }
     return ans;
 }
 int lowerbound(int x) {
     int L = , R = n, ans = ;
     while (L <= R) {
     int mid = (L+R)>>;
     if (w[mid].x < x) L = mid+;
     else R = mid-, ans = mid;
     }
     return ans;
 }
 int upperbound(int x) {
     int L = , R = n, ans = ;
     while (L <= R) {
     int mid = (L+R)>>;
     if (w[mid].x > x) R = mid-;
     else L = mid+, ans = mid;
     }
     return ans;
 }
 void work() {
     scanf("%d%d%d", &n, &q, &a);
     for (int i = ; i <= n; i++) scanf("%d", &w[i].x), w[i].id = i;
     sort(w+, w++n);
     for (int i = ; i < n; i++) {
     scanf("%d%d%d", &u, &v, &c);
     add(u, v, c); add(v, u, c);
     }
     dfs1(, , ), dfs2(, , );
     for (int i = ; i <= n; i++) val[i] += val[i-];
     for (int i = ; i <= n; i++) {
     T.root[i] = T.root[i-];
     lca_update(T.root[i], w[i].id, T.pre[i-]);
     T.pre[i] = T.pos, sumdist[i] = sumdist[i-]+dist[w[i].id];
     }
     LL ans = ;
     while (q--) {
     scanf("%d%d%d", &u, &x1, &x2);
     x1 = (x1+ans)%a, x2 = (x2+ans)%a;
     if (x1 > x2) swap(x1, x2);
     x1 = lowerbound(x1), x2 = upperbound(x2);
     LL a1 = lca_query(T.root[x1-], u), a2 = lca_query(T.root[x2], u);
     ans = (x2-x1+)*dist[u]+sumdist[x2]-sumdist[x1-]-(a2-a1)*;
     printf("%lld\n", ans);
     }
 }
 int main() {
     work();
     return ;
 }

主席树

upd 18.1.8：拿动态点分玩♂下这道题。

网上题解看不懂，自己 YY 了一个做 Fa♂。似乎和题解是一样的...

首先建成点分树后，我们用一个数据结构来维护一下所有点到重心的距离，记点分树上 $o$ 的父亲为 $fa_o$ ，并维护所有点到 $fa_o$ 的距离。

我们可以用 $vector$ 来存下这些数据。对于查询 $[L, R]$ 我们可以二分 $vector$ 。所以我们先不讨论范围问题。

查询时，我们发现，在点分树上爬的时候，我们需要统计除了来的子树外的其他子树中所有节点到当前重心的距离，并且加上这一部分通过重心到询问的点的距离。

如何求这一部分通过重心到询问的点的距离？我们可以在处理上个重心的时候预先减去 $size_x*dist(o, fa_x)$ ，再在处理这个重心时加上 $size_x*dist(x, o)$ 。注意 $x$ 是当前处理的重心，即上述两式中 $x$ 的含义不一样。

如何统计除了来的子树外的其他子树中所有节点到当前重心的距离？也用上面的思想，我们可以先减去以上一个重心为根的子树中所有点到当前处理的的重心的距离和，然后再直接加上以当前处理的重心为根的子树中所有的点到重心的距离。

总时间复杂度就是 $O((n+q)log_2 ^2 n)$ 。

 //It is made by Awson on 2018.1.8
 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define RE register
 #define lowbit(x) ((x)&(-(x)))
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 #define Swap(a, b) ((a) ^= (b), (b) ^= (a), (a) ^= (b))
 using namespace std;
 const int N = ;
 const int INF = ~0u>>;
 void read(int &x) {
     char ch; bool flag = ;
     for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || ); ch = getchar());
     for (x = ; isdigit(ch); x = (x<<)+(x<<)+ch-, ch = getchar());
     x *= -*flag;
 }

 int n, q, A, col[N+], a, b, c;
 struct tt {int to, next, cost; }edge[(N<<)+];
 int path[N+], top;
 struct arr {
     LL x, xlca; int id;
     arr() {}
     arr(LL _x, LL _xlca, int _id) {x = _x, xlca = _xlca, id = _id; }
     bool operator < (const arr &b) const {return id < b.id; }
 };
 vector<arr>d[N+];
 int fa[N+];
 LL ans;
 void add(int u, int v, int c) {
     edge[++top].to = v;
     edge[top].next = path[u];
     edge[top].cost = c;
     path[u] = top;
 }
 namespace LCA {
     int bin[], lim, dep[N+], fa[N+][];
     LL dis[N+];
     void dfs(int o, int depth, int father, LL dist) {
     dis[o] = dist;
     fa[o][] = father, dep[o] = depth;
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != father) dfs(edge[i].to, depth+, o, dist+edge[i].cost);
     }
     int query(int x, int y) {
     if (dep[x] < dep[y]) Swap(x, y);
     for (int i = lim; i >= ; i--) if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
     if (x == y) return x;
     for (int i = lim; i >= ; i--) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
     return fa[x][];
     }
     LL dist(int x, int y) {return dis[x]+dis[y]-(dis[query(x, y)]<<); }
     void main() {
     lim = log(n)/log(), bin[] = ; for (int i = ; i <= ; i++) bin[i] = bin[i-]<<;
     dfs(, , , );
     for (int t = ; t <= lim; t++) for (int i = ; i <= n; i++) fa[i][t] = fa[fa[i][t-]][t-];
     }
 }
 namespace Point_divide {
     int size[N+], mx[N+], vis[N+], minsize, root;
     void get_size(int o, int fa) {
     size[o] = , mx[o] = ;
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) {
         get_size(edge[i].to, o);
         size[o] += size[edge[i].to];
         if (size[edge[i].to] > mx[o]) mx[o] = size[edge[i].to];
         }
     }
     void get_root(int o, int pa, int fa) {
     mx[o] = Max(mx[o], size[pa]-size[o]);
     if (mx[o] < minsize) minsize = mx[o], root = o;
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_root(edge[i].to, pa, o);
     }
     void get_dist(int o, int rt, int pa, int fa, int dist) {
     d[rt].push_back(arr(dist, LCA::dist(pa, o), col[o]));
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_dist(edge[i].to, rt, pa, o, dist+edge[i].cost);
     }
     void solve(int o, int father) {
     minsize = INF; get_size(o, ), get_root(o, o, );
     vis[root] = , fa[root] = father; d[root].push_back(arr(, LCA::dist(root, father), col[root])); int rt = root;
     for (int i = path[root]; i; i = edge[i].next)
         if (!vis[edge[i].to]) get_dist(edge[i].to, root, father, root, edge[i].cost);
     d[root].push_back(arr(, , -));
     sort(d[root].begin(), d[root].end()); int size = d[root].size();
     for (int i = ; i < size; i++) d[root][i].x += d[root][i-].x, d[root][i].xlca += d[root][i-].xlca;
     for (int i = path[root]; i; i = edge[i].next)
         if (!vis[edge[i].to]) solve(edge[i].to, rt);
     }
     void main() {solve(, ); }
 }
 int upperbound(int o, int key) {
     int L = , R = d[o].size()-, mid, ans = R;
     while (L <= R) {
     mid = (L+R)>>;
     if (d[o][mid].id <= key) L = mid+, ans = mid;
     else R = mid-;
     }
     return ans;
 }
 int lowerbound(int o, int key) {
     int L = , R = d[o].size()-, mid, ans = ;
     while (L <= R) {
     mid = (L+R)>>;
     if (d[o][mid].id <= key) L = mid+, ans = mid;
     else R = mid-;
     }
     return ans;
 }
 void query(int o, int l, int r) {
     for (int x = o, L, R; x; x = fa[x]) {
     R = upperbound(x, r), L = lowerbound(x, l-);
     ans += (R-L)*LCA::dist(x, o);
     if (fa[x]) ans -= d[x][R].xlca-d[x][L].xlca+(LL)(R-L)*LCA::dist(fa[x], o);
     ans += d[x][R].x-d[x][L].x;
     }
 }
 void work() {
     read(n), read(q), read(A);
     for (int i = ; i <= n; i++) read(col[i]);
     for (int i = ; i < n; i++) read(a), read(b), read(c), add(a, b, c), add(b, a, c);
     LCA::main(); Point_divide::main();
     while (q--) {
     read(c), read(a), read(b); a = (ans+a)%A, b = (ans+b)%A;
     if (a > b) Swap(a, b); ans = ;
     query(c, a, b); printf("%lld\n", ans);
     }
 }
 int main() {
     work();
     return ;
 }

动态点分