2020.9.26 360笔试第二题

题目大意
给出一个带权无向图，没有自环和重边，给出两个节点s和t，求从s到达t的路径中的所有边里，边权最大的边的权至少有多大。保证s与t连通。
用例以n（节点个数）、m（边数）、s、t，然后m行u、v、w（权的大小）给出，比如：
5 6 1 5
1 5 100
1 2 10
2 5 5
1 3 3
3 4 2
4 5 1
选择从1->3->4->5的路径，经过3条w分别为3、2、1的边，因此答案为3。如果选择1->5或1->2->5则最大边权分别为100和10，都比3大。
作者：刘禅挥泪斩孔明
链接：https://www.nowcoder.com/discuss/526817?type=post&order=create&pos=&page=0&channel=1009&source_id=search_post
来源：牛客网

思路
类似kruskal算法，先按权的大小升序排序，然后每次依次增加一条边，看s与t是否已经连通，如果此时变得连通，返回此边的权。为什么正确呢？因为在加入这条边之前所有权值小于它的边都已加入图中，但仍未使s与t连通，说明答案不可能比其权值w1小，而加入它以后s与t已经连通，那么必定能找到一条从s到t的路径，且路径上的边最大权值不大于w1（因为权值比w1大的边此时还没加入图中），因此w1就是答案。为了快速地判定s与t的连通性，使用并查集。

#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 100005, M = 200005;

struct Edge {
    int u, v, w;
    bool operator< (Edge const& e) const { return w < e.w;}
} es[M];
int n, m, s, t, par[N], rk[N];

//并查集
int find(int x) { return x == par[x] ? x : (par[x] = find(par[x]));}
bool same(int x, int y) { return find(x) == find(y);}
void unite(int x, int y) {
    if ((x = find(x)) == (y = find(y))) return;
    if (rk[x] < rk[y]) {
        par[x] = y;
    } else {
        par[y] = x;
        if (rk[x] == rk[y]) rk[x]++;
    }
}

int solve() {
    sort(es, es + m);//按权值排序，Edge类已重载operator<
    for (int i = 0; i < n; i++) par[i] = i;//初始化并查集
    for (int i = 0; i < m; i++) {
        unite(es[i].u, es[i].v);//将这条边加入
        if (same(s, t)) return es[i].w;//如果此时s与t连通返回此边的边权。
    }
    return -1;
}

int main() {
    scanf("%d%d%d%d", &n, &m, &s, &t);
    s--, t--;//题目给的点编号是1~n，个人习惯从0开始编号，所以自减1，下同。
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &es[i].u, &es[i].v, &es[i].w);
        es[i].u--, es[i].v--;
    }
    printf("%d\n", solve());
}

竟然是最小生成树的变种，图论还是差的一，这代码写的太舒服了，CV一波，我大概只会暴力的遍历图吧。。。。

附上自己写的暴力，bfs 和bfs，找到s到e的可行路径，寻找最小值，虽然会超时，就当练习了

import java.util.*;

public class Main {
    static Scanner in = new Scanner(System.in);
    static int n,m,s,e;
    static int[][] mp;
    static List<Node> st = new ArrayList<>();
    static boolean[] vis;
    static int ans = Integer.MAX_VALUE;
    //maxPath代表从s到e的一条可行路径中的最大权值
    static  void dfs(int x,int maxPath){
        if(maxPath>=ans) return;
        if(x == e){
            ans = Math.min(ans,maxPath);
            return;
        }
        for (int i = 1; i <= n; i++) {
            if(x == s) maxPath = -1;//每次从S开始搜索时需要重置，
            if(!vis[i]&&mp[x][i]!=0){
                vis[i] = true;
                maxPath = Math.max(maxPath,mp[x][i]);
                dfs(i,maxPath);
                vis[i] = false;
            }
        }
    }
    static void bfs(){
        LinkedList<Node> q = new LinkedList<Node>();
        //maxPath用来存储s到e路径中的最大权值
        //为什么这里需要一个数组，因为dfs方式是走到底然后回溯的，用一个变量更新即可，而
        //bfs则是一步一步扩展的，必须要用一个数组来分别记录更新每条路径的最大权值
        int[][] maxPath = new int[n+1][n+1];
        for (int i = 1; i <= n ; i++) {
            Arrays.fill(maxPath[i],-1);
        }
        //将s一步可达的点入队
        for (int i = 1; i <= n; i++) {
            if(i!=s&&mp[s][i]!=0){
                Node nw = new Node(s,i,mp[s][i]);
                q.add(nw);
                maxPath[s][i] = mp[s][i];
                if(i == e){
                    ans = Math.min(ans,mp[s][i]);
                }
            }
        }

        while(!q.isEmpty()){
            Node cur = q.poll();
            for (int i = 1; i <= n; i++) {
                if(i!=cur.v&&mp[cur.v][i]!=0){
                    Node nw = new Node(cur.v,i,mp[cur.v][i]);
                    maxPath[cur.v][i] = Math.max(maxPath[cur.u][cur.v],mp[cur.v][i]);
                    q.add(nw);
                    if(i == e){
                        ans = Math.min(ans,maxPath[cur.v][i]);
                    }
                }
            }

      }
    }
    public static void main(String[] args) {
         n = in.nextInt();
         m = in.nextInt();
         s = in.nextInt();
         e = in.nextInt();
        mp = new int[n+1][n+1];
        vis = new boolean[n+1];
        Arrays.fill(vis,false);

        int v,u,w;
        for (int i = 0; i < m; i++) {
            v = in.nextInt();
            u = in.nextInt();
            w = in.nextInt();
            mp[v][u] = w;
        }

        vis[s] = true;
        dfs(s,-1);
        //bfs();
        System.out.println(ans);
    }
}

class Node{
    int u,v,w;
    Node(int u,int v,int w){
        this.u = u;
        this.v = v;
        this.w = w;
    }
}