[ONTAK2010]Peaks

题目大意：
　　一个图上有$n(n\leq100000)$个带权点，$m(m\leq500000)$条带权边。有$q(q\leq500000)$组询问，每次询问从点$v$出发，只经过权值小于等于$x$的边能到达的点中，权值第$k$大的点权。

思路：
　　离线处理每个询问。将询问和边分别按权值排序，处理到当前询问时，将权值小于等于$x$的边加入到图中。用权值线段树维护每个连通块的权值。点的联通情况用并查集维护（相当于Kruskal），权值线段树直接合并。时间复杂度$O(n\log n+m\log m+q\log q+q\log n)$。

 #include<cstdio>
 #include<cctype>
 #include<algorithm>
 inline int getint() {
     register char ch;
     while(!isdigit(ch=getchar()));
     register int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 const int N=,M=,Q=;
 int h[N],tmp[N],ans[Q];
 struct Edge {
     int u,v,w;
     bool operator < (const Edge &another) const {
         return w<another.w;
     }
 };
 Edge e[M];
 struct Query {
     int v,x,k,id;
     bool operator < (const Query &another) const {
         return x<another.x;
     }
 };
 Query q[Q];
 struct DisjointSet {
     int anc[N];
     int find(const int &x) {
         return x==anc[x]?x:anc[x]=find(anc[x]);
     }
     void reset(const int &n) {
         for(register int i=;i<=n;i++) anc[i]=i;
     }
     void merge(const int &x,const int &y) {
         anc[find(y)]=find(x);
     }
     bool same(const int &x,const int &y) {
         return find(x)==find(y);
     }
 };
 DisjointSet s;
 class SegmentTree {
     private:
         struct Node {
             int val;
             Node *left,*right;
             Node(const int &v):val(v),left(NULL),right(NULL) {}
         };
         void modify(Node *&p,const int &b,const int &e,const int &x) {
             p=new Node();
             if(b==e) return;
             const int mid=(b+e)>>;
             if(x<=mid) modify(p->left,b,mid,x);
             if(x>mid) modify(p->right,mid+,e,x);
         }
     public:
         Node *root[N];
         void reset(const int &n) {
             for(register int i=;i<=n;i++) {
                 modify(root[i],,tmp[],h[i]);
             }
         }
         void merge(Node *&p1,Node *const &p2) {
             if(!p1) {
                 p1=p2;
                 return;
             }
             if(!p2) return;
             p1->val+=p2->val;
             merge(p1->left,p2->left);
             merge(p1->right,p2->right);
             delete p2;
         }
         int query(const Node *const &p,const int &b,const int &e,const int &k) const {
             if(p->val<k) return -;
             if(b==e) return b;
             const int mid=(b+e)>>;
             if(!p->right) return query(p->left,b,mid,k);
             if(k<=p->right->val) return query(p->right,mid+,e,k);
             return query(p->left,b,mid,k-p->right->val);
         }
 };
 SegmentTree t;
 inline void add_edge(const Edge &e) {
     if(s.same(e.u,e.v)) return;
     t.merge(t.root[s.find(e.u)],t.root[s.find(e.v)]);
     s.merge(e.u,e.v);
 }
 int main() {
     const int n=getint(),m=getint(),cnt_q=getint();
     for(register int i=;i<=n;i++) {
         tmp[i]=h[i]=getint();
     }
     std::sort(&tmp[],&tmp[n]+);
     tmp[]=std::unique(&tmp[],&tmp[n]+)-&tmp[];
     for(register int i=;i<=n;i++) {
         h[i]=std::lower_bound(&tmp[],&tmp[tmp[]]+,h[i])-&tmp[];
     }
     for(register int i=;i<m;i++) {
         const int u=getint(),v=getint(),w=getint();
         e[i]=(Edge){u,v,w};
     }
     std::sort(&e[],&e[m]);
     for(register int i=;i<cnt_q;i++) {
         const int v=getint(),x=getint(),k=getint();
         q[i]=(Query){v,x,k,i};
     }
     std::sort(&q[],&q[cnt_q]);
     s.reset(n);
     t.reset(n);
     for(register int i=,p=;i<cnt_q;i++) {
         while(p<m&&e[p].w<=q[i].x) add_edge(e[p++]);
         ans[q[i].id]=t.query(t.root[s.find(q[i].v)],,tmp[],q[i].k);
     }
     for(register int i=;i<cnt_q;i++) {
         printf("%d\n",~ans[i]?tmp[ans[i]]:-);
     }
     return ;
 }