Bzoj5188/洛谷P4185 [Usaco2018 Jan]MooTube（并查集）

题面

Bzoj

洛谷

题解

最暴力的方法是直接判两个点之间的路径最小值是否\(\geq k\)，用\(Dijkstra\)可以做到该算法最快效率，但是空间复杂度始终是\(O(n^2)\)的，会\(MLE\)，其实仔细观察一下，会发现对于一个满足某个\(k\)的路径\(dis\)，它一定会满足\(\forall k'\leq k\)，同时，对于任意一条长度大于\(|dis|\)的路径，它也满足又满足这些\(k\)，甚至更多的\(k'\)，于是我们从这个性质入手。

具体来说，就是将询问离线化，按照\(k\)值从大到小排序，然后将路径按照\(r\)值从大到小排序。线性处理询问，当处理某个询问时，将当前满足的所有边加入到并查集中，这个询问的答案就是\(v\)所在的并查集的\(size-1\)（自己本身不算），整个算法的复杂度是\(O(n+m)\)的。

#include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using std::queue; using std::unique;
using std::lower_bound;
using std::min; using std::max;
using std::swap; using std::sort;
//typedef long long ll;

template<typename T>
void read(T &x) {
    int flag = 1; x = 0; char ch = getchar();
    while(ch < '0' || ch > '9') { if(ch == '-') flag = -flag; ch = getchar(); }
    while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar(); x *= flag;
}

const int N = 1e5 + 10;
int n, m, ans[N], fa[N], siz[N];
struct Edge { int u, v, w; } e[N];
struct Ques { int k, v, id; } q[N];
bool operator < (const Edge &a, const Edge &b) { return a.w > b.w; }
bool operator < (const Ques &a, const Ques &b) { return a.k > b.k; }

int find(int x) { return fa[x] == -1 ? x : fa[x] = find(fa[x]); }
void unionn(int x, int y) {
    int fx = find(x), fy = find(y);
    if(fx == fy) return ;
    fa[fx] = fy, siz[fy] += siz[fx];
}

int main () {
    read(n), read(m); memset(fa, -1, sizeof fa);
    for(int i = 1; i <= n; ++i) siz[i] = 1;
    for(int i = 1; i < n; ++i)
        read(e[i].u), read(e[i].v), read(e[i].w);
    for(int i = 1; i <= m; ++i)
        read(q[i].k), read(q[i].v), q[i].id = i;
    sort(e + 1, e + n), sort(q + 1, q + m + 1);
    for(int i = 1, j = 1; i <= m; ++i) {
        while(j < n)
            if(e[j].w >= q[i].k) unionn(e[j].u, e[j].v), ++j;
            else break;
        ans[q[i].id] = siz[find(q[i].v)];
    }
    for(int i = 1; i <= m; ++i) printf("%d\n", ans[i] - 1);
    return 0;
} 

转载于:https://www.cnblogs.com/water-mi/p/10312963.html