Kruskal重构树

大意：

　　Kruskal重构树即是将正常Kruskal算法中的最小生成树的边当作点，连接两个点集，且满足大（小）根堆性质，那么求两点间经过路径长度最值即它们的LCA的点权。

证明：

　　对于两个集合，它们之间的路径最值即连通这两个集合的最值边，且边已经过排序，故显然满足条件。

　　证毕。

---

经典用法：

　　· 求两点间路径最小（大）值的最大（小）值。

　　· 求当前点出发，仅经过边权小（大）于等于x的边可到达的所有点。

　　那么求出点权最小（大）的那个代表边的节点，答案为其子树。

例题：

　　洛谷 - Problem 4197 - Peaks

　　（在线）Krusal重构树 + 主席树

　　

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

const int MAXN = 1e05 + 10;
const int MAXM = 5e05 + 10;
const int MAXT = (MAXN << 4) + (MAXN << 2);

const int INF = 0x7fffffff;

struct LinkedForwardStar {
    int to;
    
    int next;
} ;

LinkedForwardStar Link[MAXM << 2];
int Head[MAXN << 1]= {0};
int size = 0;

void Insert (int u, int v) {
    Link[++ size].to = v;
    Link[size].next = Head[u];
    
    Head[u] = size;
}

int Root;

int N, M, Q;

int Height[MAXN];

struct Line {
    int u, v;
    int w;
    
    Line () {}
    
    Line (int fu, int fv, int fw) :
        u (fu), v (fv), w (fw) {}
    
    bool operator < (const Line& p) const {
        return w < p.w;
    }
} ;

Line Edges[MAXM];

int Ances[MAXN << 1];

int Find (int x) {
    return x == Ances[x] ? x : Ances[x] = Find (Ances[x]);
}

int nodes;

int Val[MAXN << 1];

void Kruskal () {
    for (int i = 1; i <= N; i ++)
        Ances[i] = i;
    
    sort (Edges + 1, Edges + M + 1);
    
    for (int i = 1; i <= M; i ++) {
        int u = Edges[i].u;
        int v = Edges[i].v;
        int w = Edges[i].w;
        
        int fu = Find (u);
        int fv = Find (v);
        
        if (fu == fv)
            continue;
        
        int newnode = ++ nodes;
        Val[newnode] = w;
        Ances[newnode] = Ances[fu] = Ances[fv] = nodes;
        Insert (newnode, fu), Insert (fu, newnode);
        Insert (newnode, fv), Insert (fv, newnode);
    }
}

int Father[MAXN << 1][30];

int Belong[MAXN];
int dfsord = 0; 

int fSize[MAXN << 1];
int Minleft[MAXN << 1], Maxright[MAXN << 1];

bool Vis[MAXN << 1]= {false};

void DFS (int root, int father) {
    Vis[root] = true;
    fSize[root] = 0;
    Minleft[root] = INF, Maxright[root] = 0;
    Father[root][0] = father;
    for (int j = 1; j <= 20; j ++) {
        if (! Father[root][j - 1])
            continue;
        
        Father[root][j] = Father[Father[root][j - 1]][j - 1];
    }
    
    int cnt = 0;
    for (int i = Head[root]; i; i = Link[i].next) {
        int v = Link[i].to;
        
        if (v == father)
            continue;
        
        DFS (v, root);
        
        cnt ++;
        fSize[root] += fSize[v];
        Minleft[root] = min (Minleft[root], Minleft[v]);
        Maxright[root] = max (Maxright[root], Maxright[v]);
    }
    
    if (! cnt) {
        Belong[++ dfsord] = root;
        
        fSize[root] = 1;
        Minleft[root] = dfsord;
        Maxright[root] = dfsord;
    }
}

int Findpos (int u, int minval) {
    for (int j = 20; j >= 0; j --)
        if (Father[u][j] && Val[Father[u][j]] <= minval)
            u = Father[u][j];
    
    return u;
}

int Mapping[MAXN];
int sizemapp = 0;

int ChiefTree[MAXT];
int treenode = 0;

int Left[MAXT], Right[MAXT];
int Size[MAXT];

int Build (int left, int right) {
    int root = ++ treenode;
    
    Size[root] = 0;
    
    if (left == right)
        return root;
    
    int mid = (left + right) >> 1;
    
    Left[root] = Build (left, mid);
    Right[root] = Build (mid + 1, right);
    
    return root;
}

int Modify (int pre, int left, int right, int pos) {
    int root = ++ treenode;
    
    Left[root] = Left[pre], Right[root] = Right[pre];
    Size[root] = Size[pre] + 1;
    
    if (left == right)
        return root;
    
    int mid = (left + right) >> 1;
    
    if (pos <= mid)
        Left[root] = Modify (Left[pre], left, mid, pos);
    else
        Right[root] = Modify (Right[pre], mid + 1, right, pos);
    
    return root;
}

int Query (int Sl, int Sr, int left, int right, int k) {
    if (left == right)
        return Mapping[left];
    
    int psize = Size[Right[Sr]] - Size[Right[Sl]];
    
    int mid = (left + right) >> 1;
    
    if (psize >= k)
        return Query (Right[Sl], Right[Sr], mid + 1, right, k);
    else
        return Query (Left[Sl], Left[Sr], left, mid, k - psize);
}

int main () {
    scanf ("%d%d%d", & N, & M, & Q);
    nodes = N;
    
    for (int i = 1; i <= N; i ++) {
        scanf ("%d", & Height[i]);
        Mapping[++ sizemapp] = Height[i];
    }
    
    sort (Mapping + 1, Mapping + sizemapp + 1);
    sizemapp = unique (Mapping + 1, Mapping + sizemapp + 1) - Mapping - 1;
    
    for (int i = 1; i <= M; i ++) {
        int u, v, w;
        scanf ("%d%d%d", & u, & v, & w);
        
        Edges[i] = Line (u, v, w);
    }
    
    Kruskal ();
    
    for (int i = 1; i <= nodes; i ++)
        if (! Vis[i]) {
            Root = Find (i);
            DFS (Root, 0);
        }
    
    ChiefTree[0] = Build (1, sizemapp);
    for (int i = 1; i <= dfsord; i ++) {
        int pos = lower_bound (Mapping + 1, Mapping + sizemapp, Height[Belong[i]]) - Mapping;
        ChiefTree[i] = Modify (ChiefTree[i - 1], 1, sizemapp, pos);
    }
    
    for (int Case = 1; Case <= Q; Case ++) {
        int from, minval, k;
        scanf ("%d%d%d", & from, & minval, & k);
        
        int maxpos = Findpos (from, minval);
        if (fSize[maxpos] < k) {
            puts ("-1");
            continue;
        }
        
        int ans = Query (ChiefTree[Minleft[maxpos] - 1], ChiefTree[Maxright[maxpos]], 1, sizemapp, k);
        
        printf ("%d
", ans);
    }
    
    return 0;
}

/*
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
*/