边权最大值最小问题

对于边权最大值最小的问题
思路非常简单：
首先是排序后跑最小生成树(Kruskal)
每一次循环都判断一下起点和终点是否联通了
如果联通了，输出当前边的边权即可。

思想解释就是：
我们首先保证了边权是单调递增的，如果在某一个时刻，将两个联通块进行了合并，使得起点和终点能够联通，而在前一个时刻不能
我们想，此后我们可能合并更多的联通块，可能有更多的生成树，但是因为边权是递增的
所以此后生成树的最大边的边权肯定比当前生成树的最大边的边权小，所以当前边的边权就是起点到终点的边权最大值最小的情况
如果是1—n，实际上就是一颗最小生成树的最大边

#include<bits/stdc++.h>
#define uint unsigned int
using namespace std;
const int maxn = 100086;
const int maxm = 600086;
struct shiki {
    int x, y, val;
}e[maxm];
int n, m, s, t;
int fa[maxn];

inline int read() {
    int x = 0, y = 1;
    char ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') y = -1;
        ch = getchar();
    }
    while(isdigit(ch)) {
        x = (x << 1) + (x << 3) + ch - '0';
        ch = getchar();
    }
    return x * y;
}

inline bool cmp(shiki a, shiki b) {
return a.val < b.val;}

int getfather(int x) {
    if(x == fa[x]) return x;
    return fa[x] = getfather(fa[x]);
}

int main() {
    n = read(), m = read(), s = read(), t = read();
    for(register uint i = 1; i <= m; ++i) 
        e[i].x = read(), e[i].y = read(), e[i].val = read();
    sort(e + 1, e + m + 1, cmp);
    for(register uint i = 1; i <= n; ++i) fa[i] = i;
    for(register uint i = 1; i <= m; ++i) {
        int u = getfather(e[i].x);
        int v = getfather(e[i].y);
        if(u != v) fa[u] = v;
        if(getfather(s) == getfather(t)) {
            cout << e[i].val << '\n';
            return 0;
        }
    }
    return 0;
}