P4197 Peaks

Posted 2021-01-31 olinr

(color{#0066ff}{题目描述})

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

(color{#0066ff}{输入格式})

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

(color{#0066ff}{输出格式})

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

(color{#0066ff}{输入样例})

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

(color{#0066ff}{输出样例})

6
1
-1
8

(color{#0066ff}{数据范围与提示})

(N leq 10^5, 0 leq M, Q leq 5 * 10^5, h_i, c, x leq 10^9)

(color{#0066ff}{题解})

Kruskal重构树

以困难程度为关键字建立大根堆

倍增找到最浅点

对于子树内的叶子，就是能到的所有点

找到这些点的第k大

考虑dfs序

只记录叶子节点的dfs序

同一子树内dfs序连续

用主席树维护就行了

#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; int x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int maxn = 8e5 + 100;
struct tree {
protected:
    struct node {
        int num;
        node *ch[2];
        node(int num = 0): num(num) {
            ch[0] = ch[1] = NULL;
        }
        void *operator new (size_t) {
            static node *S = NULL, *T = NULL;
            return (S == T) && (T = (S = new node[1024]) + 1024), S++;
        }
    };
    node *root[maxn];
    void ins(node *&o, node *ls, int l, int r, int val) {
        o = new node();
        *o = *ls;
        o->num++;
        if(l == r) return;
        int mid = (l + r) >> 1;
        if(val <= mid) ins(o->ch[0], ls->ch[0], l, mid, val);
        else ins(o->ch[1], ls->ch[1], mid + 1, r, val);
    }
    int query(node *x, node *y, int l, int r, int k) {
        if(l == r) return l;
        int siz = y->ch[0]->num - x->ch[0]->num;
        int mid = (l + r) >> 1;
        if(k <= siz) return query(x->ch[0], y->ch[0], l, mid, k);
        else return query(x->ch[1], y->ch[1], mid + 1, r, k - siz);
    }
    void init() {
        root[0] = new node();
        root[0]->ch[0] = root[0]->ch[1] = root[0];
    }
public:
    tree() { init(); }
    void ins(int *s, int *t, int *m, int n, int len) {
        for(int i = 1; i <= n; i++) ins(root[i], root[i - 1], 1, len, std::lower_bound(t + 1, t + len + 1, s[m[i]]) - t);
    }
    int query(int l, int r, int k, int len) { return query(root[l - 1], root[r], 1, len, k); }
};
int n, m, q;
struct E {
    int x, y, z;
    bool operator < (const E &b) const {
        return z < b.z;
    }
}e[maxn];
struct node {
    int to;
    node *nxt;
    node(int to = 0, node *nxt = NULL): to(to), nxt(nxt) {}
    void *operator new (size_t) {
        static node *S = NULL, *T = NULL;
        return (S == T) && (T = (S = new node[1024]) + 1024), S++;
    }
};
node *head[maxn];
tree s;
int h[maxn], l[maxn], r[maxn], fa[maxn], hh[maxn], len = 1;
int findset(int x) { return x == fa[x]? fa[x] : fa[x] = findset(fa[x]); }
int f[maxn][26], dfn, redfn[maxn];
void add(int from, int to) {
    head[from] = new node(to, head[from]);
}
void dfs(int x, int ff) {
    f[x][0] = ff;
    if(x <= n) redfn[++dfn] = x;
    else l[x] = dfn + 1;
    for(node *i = head[x]; i; i = i->nxt) 
        if(i->to != ff) dfs(i->to, x);
    if(x > n) r[x] = dfn;
}
int query(int v, int x, int k) {
    for(int i = 24; i >= 0; i--) if(f[v][i] && h[f[v][i]] <= x) v = f[v][i];
    if(r[v] - l[v] + 1 < k) return -1;
    return hh[s.query(l[v], r[v], r[v] - l[v] + 2 - k, len)];
}
int main() {
    n = in(), m = in(), q = in();
    for(int i = 1; i <= n; i++) hh[i] = h[i] = in(), fa[i] = i;
    for(int i = 1; i <= m; i++) e[i].x = in(), e[i].y = in(), e[i].z = in();
    std::sort(hh + 1, hh + n + 1);
    std::sort(e + 1, e + m + 1);
    for(int i = 2; i <= n; i++) if(hh[i] != hh[i - 1]) hh[++len] = hh[i];
    int cnt = n, tot = 0;
    for(int i = 1; i <= m; i++) {
        int x = findset(e[i].x);
        int y = findset(e[i].y);
        if(x != y) {
            fa[x] = fa[y] = ++cnt;
            fa[cnt] = cnt;
            h[cnt] = e[i].z;
            add(cnt, x), add(cnt, y);
            tot++;
        }
        if(tot == n - 1) break;
    }
    dfs(cnt, 0);
    for(int j = 1; j <= 24; j++)
        for(int i = 1; i <= cnt; i++) 
            f[i][j] = f[f[i][j - 1]][j - 1];
    s.ins(h, hh, redfn, n, len);
    int v, x, k;
    while(q --> 0) {
        v = in(), x = in(), k = in();
        printf("%d
", query(v, x, k));
    }
    return 0;
}