【线段树合并】bzoj3545: [ONTAK2010]Peaks

1A还行

Description

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

Input

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

Output

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

HINT

【数据范围】

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

---

题目分析

题目所求的是“小于等于x的边”所成连通块中的第k大，这里就会自然想到处理这一类连通块问题的策略：从小到大加边维护连通块，并在这个过程中离线处理查询。

现在要维护的连通块信息是无序的集合，于是第一反应就是用set合并。但是显而易见的是，set不能处理第k大问题（话说暑假做“不等式组”那题时候第一反应就是用multiset处理，但是当时被查询key和第k大困扰了很久）。有一种常见的方法是采用权值线段树实现set的功能，这样一来就可以处理一些基础的查询问题。

处理完了连通块和维护的操作，接下去的问题就是合并。权值线段树本质上还是线段树，所以使用线段树合并的套路就可以保证这一部分的复杂度。

感觉是比较套路和数据结构的题，好像没什么营养……

 #include<bits/stdc++.h>
 const int maxn = ;
 const int maxq = ;
 const int maxm = ;
 const int maxNode = ;

 struct node
 {
     int l,r,val;
 }a[maxNode];
 struct QRs
 {
     int v,x,k,id;
     bool operator < (QRs a) const
     {
         return x < a.x;
     }
 }qr[maxq];
 struct Edge
 {
     int u,v,val;
     Edge(int a=, int b=, int c=):u(a),v(b),val(c) {}
     bool operator < (Edge a) const
     {
         return val < a.val;
     }
 }edges[maxm];
 int n,m,q,dal,tot,ans[maxq];
 int fat[maxn],h[maxn],cnt[maxn],rt[maxn];

 int read()
 {
     char ch = getchar();
     int num = , fl = ;
     for (; !isdigit(ch); ch=getchar())
         if (ch=='-') fl = -;
     for (; isdigit(ch); ch=getchar())
         num = (num<<)+(num<<)+ch-;
     return num*fl;
 }
 int find(int x){return x==fat[x]?x:fat[x]=find(fat[x]);}
 int query(int rt, int l, int r, int c)
 {
     if (l==r) return l;
     int mid = (l+r)>>;
     if (c <= a[a[rt].l].val)
         return query(a[rt].l, l, mid, c);
     return query(a[rt].r, mid+, r, c-a[a[rt].l].val);
 }
 int queryPos(int v, int k)
 {
     int anc = find(v);
     if (a[rt[anc]].val < k) return -;
     return cnt[query(rt[anc], , cnt[], a[rt[anc]].val-k+)];
 }
 void update(int &rt, int l, int r, int c)
 {
     if (!rt) rt = ++tot;
     ++a[rt].val;
     if (l==r) return;
     int mid = (l+r)>>;
     if (c <= mid) update(a[rt].l, l, mid, c);
     else update(a[rt].r, mid+, r, c);
 }
 void merge(int &u, int v)
 {
     if (u*v==){
         u = u?u:v;
         return;
     }
     a[u].val += a[v].val;
     merge(a[u].l, a[v].l);
     merge(a[u].r, a[v].r);
 }
 int main()
 {
     n = read(), m = read(), q = read();
     for (int i=; i<=n; i++) h[i] = cnt[i] = read(), fat[i] = i;
     for (int i=; i<=m; i++)
         edges[i].u = read(), edges[i].v = read(), edges[i].val = read();
     for (int i=; i<=q; i++)
         qr[i].v = read(), qr[i].x = read(), qr[i].k = read(), qr[i].id = i;
     std::sort(edges+, edges+m+);
     std::sort(cnt+, cnt+n+);
     std::sort(qr+, qr+q+);
     cnt[] = std::unique(cnt+, cnt+n+)-cnt-;
     for (int i=; i<=n; i++)
     {
         h[i] = std::lower_bound(cnt+, cnt+cnt[]+, h[i])-cnt;
         update(rt[i], , cnt[], h[i]);
     }
     dal = ;
     for (int i=; i<=m; i++)
     {
         int fu = find(edges[i].u), fv = find(edges[i].v);
         if (fu!=fv){
             for (; dal<=q&&qr[dal].x < edges[i].val; ++dal)
                 ans[qr[dal].id] = queryPos(qr[dal].v, qr[dal].k);
             fat[fu] = fv, merge(rt[fv], rt[fu]);
         }
     }
     for (int i=dal; i<=q; i++)
         ans[qr[i].id] = queryPos(qr[i].v, qr[i].k);
     for (int i=; i<=q; i++) printf("%d\n",ans[i]);
     return ;
 }

END