Peaks BZOJ 3545 / Peaks加强版 BZOJ 3551

Peaks

【问题描述】

在Bytemountains有N座山峰，每座山峰有他的高度h_i。有些山峰之间有双向道路相连，共M条路径，每条路径有一个困难值，这个值越大表示越难走，现在有Q组询问，每组询问询问从点v开始只经过困难值小于等于x的路径所能到达的山峰中第k高的山峰，如果无解输出-1。

【输入格式】

第一行三个数N，M，Q。
第二行N个数，第i个数为h_i
接下来M行，每行3个数a b c，表示从a到b有一条困难值为c的双向路径。
接下来Q行，每行三个数v x k，表示一组询问。

【输出格式】

对于每组询问，输出一个整数表示答案。

【样例输入】

10 11 4
1 2 3 4 5 6 7 8 9 10
1 4 4
2 5 3
9 8 2
7 8 10
7 1 4
6 7 1
6 4 8
2 1 5
10 8 10
3 4 7
3 4 6
1 5 2
1 5 6
1 5 8
8 9 2

【样例输出】

6
1
-1
8

【数据范围】

N<=10^5, M,Q<=5*10^5, h_i,c,x<=10^9。

---

题解：

根据题意，只有最小生成树上的边是有用的

考虑Kruskal重构树

即对于每一次连边，我们新建一个节点p，将两点祖先的父亲设为p，并将边权附为p的点权

那么就有这个树上就有许多性质：

1.树是二叉树

2.点权是大根堆的结构

3.新树中两点路径点权的信息（最大值、最小值）和原树中两点路径边权的信息相等

那么根据2、3，原树中两点路径上最大的边权就是新树中两点的最近公共祖先的点权

那么处理出Dfs序，就可以用主席树维护区间第k大值（需要离散）

 #include<cmath>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;
 const int inf = ;
 const int logp = ;
 const int maxn = 1e5 + ;
 const int maxm = 5e5 + ;
 const int maxp = maxn << ;
 const int maxe = maxp << ;
 const int maxs = maxp * logp ;
 int n, m, q, p;
 int num, cnt, tot;
 int d[maxn], h[maxn];
 int fat[maxp], val[maxp];
 int rt[maxp], lc[maxs], rc[maxs], sum[maxs];
 int si[maxp], dep[maxp], dfn[maxp], pos[maxp];
 int fir[maxp], nex[maxe], ver[maxe];
 int fa[logp + ][maxp];
 int pr[logp + ], lg[maxp];
 struct edge
 {
     int x, y, z;
 };
 edge a[maxm];
 inline bool rule(edge a, edge b)
 {
     return a.z < b.z;
 }
 inline void Scan(int &x)
 {
     char c;
     bool o = false;
     while(!isdigit(c = getchar())) o = (c != '-') ? o : true;
     x = c - '';
     while(isdigit(c = getchar())) x = x *  + c - '';
     if(o) x = -x;
 }
 inline void Disc()
 {
     sort(d + , d +  + n);
     for(int i = ; i <= n; ++i) h[i] = lower_bound(d + , d +  + n, h[i]) - d;
 }
 inline int Find(int x)
 {
     return (fat[x] != x) ? fat[x] = Find(fat[x]) : x;
 }
 inline void Ins(int x, int y)
 {
     nex[++tot] = fir[x];
     fir[x] = tot;
     ver[tot] = y;
 }
 void Dfs(int u)
 {
     si[u] = ;
     dfn[u] = ++num;
     pos[num] = u;
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = ver[i];
         fa[][v] = u;
         dep[v] = dep[u] + ;
         Dfs(v);
         si[u] += si[v];
     }
 }
 inline void Kruskal()
 {
     p = n;
     sort(a + , a +  + m, rule);
     for(int i = ; i <= m; ++i)
     {
         int x = Find(a[i].x), y = Find(a[i].y);
         if(x != y)
         {
             fat[++p] = p;
             val[p] = a[i].z;
             fat[x] = fat[y] = p;
             Ins(p, x), Ins(p, y);
             if(p == (n << ) - ) break;
         }
     }
 }
 inline void Erg()
 {
     num = ;
     for(int i = ; i <= p; ++i)
         if(!dfn[i])
             Dfs(Find(i));
 }
 inline void Table()
 {
     pr[] = ;
     for(int i = ; i <= logp; ++i)
     {
         pr[i] = pr[i - ] << ;
         if(pr[i] > p) break;
         lg[pr[i]] = ;
     }
     for(int i = ; i <= p; ++i) lg[i] += lg[i - ];
 }
 inline void Rmq()
 {
     for(int k = ; k <= lg[p]; ++k)
         for(int i = ; i <= p; ++i)
         {
             if(dep[i] < pr[k]) continue;
             fa[k][i] = fa[k - ][fa[k - ][i]];
         }
 }
 int Add(int p, int l, int r, int x)
 {
     int k = ++cnt;
     sum[k] = sum[p] + ;
     if(l == r) return k;
     int mi = l + r >> ;
     if(x <= mi) lc[k] = Add(lc[p], l, mi, x), rc[k] = rc[p];
     else rc[k] = Add(rc[p], mi + , r, x), lc[k] = lc[p];
     return k;
 }
 inline void Build()
 {
     Kruskal();
     Erg();
     Table();
     Rmq();
     for(int i = ; i <= num; ++i)
     {
         int x = pos[i];
         if(x > n) rt[i] = rt[i - ];
         else rt[i] = Add(rt[i - ], , n, h[x]);
     }
 }
 inline int Jump(int x, int v)
 {
     int len = lg[dep[x]];
     for(int i = len; i >= ; --i)
         if(val[fa[i][x]] <= v)
             x = fa[i][x];
     return x;
 }
 int Query(int a, int b, int l, int r, int k)
 {
     if(l == r) return l;
     int amo = sum[rc[b]] - sum[rc[a]];
     int mi = l + r >> ;
     if(amo < k) return Query(lc[a], lc[b], l, mi, k - amo);
     return Query(rc[a], rc[b], mi + , r, k);
 }
 int Ask(int x, int v, int k)
 {
     int anc = Jump(x, v);
     int beg = rt[dfn[anc] - ];
     int end = rt[dfn[anc] + si[anc] - ];
     if(sum[end] - sum[beg] < k) return -;
     int hi = Query(beg, end, , n, k);
     return d[hi];
 }
 int main()
 {
     Scan(n), Scan(m), Scan(q);
     val[] = inf;
     for(int i = ; i <= n; ++i) Scan(h[i]), d[i] = h[i], fat[i] = i;
     Disc();
     for(int i = ; i <= m; ++i) Scan(a[i].x), Scan(a[i].y), Scan(a[i].z);
     Build();
     int ans = -;
     while(q--)
     {
         int x, v, k;
         Scan(x), Scan(v), Scan(k);
         if(ans != -) x ^= ans, v ^= ans, k ^= ans;
         ans = Ask(x, v, k);
         printf("%d\n", ans);
     }
 }