洛谷 P1396 营救 kruskal 最小生成树 并查集

题目链接：https://www.luogu.org/problemnew/show/P1396

思路：

kruskal

一开始误认为是dijkstra

后来发现题目的核心不是最短路径，而是只要s可以到t，总路径有多长没有关系

题目保证1<=s,t<=n且s<>t，保证可以从s区出发到t区。

只要该路径的每一个小段，就是两个节点之间的路径的最大值，最小即可

//思路kruskal
//一开始误认为是dijkstra
//后来发现题目的核心不是最短路径，而是只要s可以到t，总路径有多长没有关系
//题目保证1<=s,t<=n且s<>t，保证可以从s区出发到t区。
//只要该路径的每一个小段，就是两个节点之间的路径的最大值，最小即可
        import java.util.ArrayList;
        import java.util.Collections;
        import java.util.List;
        import java.util.Scanner;

        public class Main {
            static int n;
            static int m;
            static int[]parent;
            static int[]rank;
            static int a,b,c;
            static int s;
            static int t;
            
            public static void init() {
            	for(int i=1;i<=n;i++) {
            		parent[i]=-1;
            		rank[i]=0;
            	}
            }
            public static int find_root(int x) {
            	int x_root=x;
            	while(parent[x_root]!=-1) {
            		x_root=parent[x_root];
            	}
            	return x_root;
            }
            public static int union(int x,int y) {
            	int x_root=find_root(x);
            	int y_root=find_root(y);
            	if(x_root==y_root)return 0;
            	else {
            		if(rank[x_root]>rank[y_root]) {
            			parent[y_root]=x_root;
            		}
            		else if(rank[x_root]<rank[y_root]) {
            			parent[x_root]=y_root;
            		}
            		else {
            			parent[x_root]=y_root;
            			rank[y_root]++;
            		}
            		return 1;
            	}
            }
            public static void main(String[] args) {
                Scanner in=new Scanner(System.in);
                n=in.nextInt();
                m=in.nextInt();
                s=in.nextInt();
                t=in.nextInt();
                parent=new int[n+1];
                rank=new int[n+1];
                init();
                List<xi>list=new ArrayList<xi>();
                for(int i=0;i<m;i++) {
                	list.add(new xi(in.nextInt(),in.nextInt(),in.nextInt()));
                }
                Collections.sort(list);
                int k=0;
                int loc=0;
                for(int i=0;i<m;i++) {
                	//if(k==n-1)break;
                	//发现s和t在一个集合中了，就跳出，此时，就是最后一次加入的边使这两个节点在一个集合中了
                	//那么输出最后加入的边就是所要求的，经过道路的拥挤度最大值的最小值
                	if(find_root(s)==find_root(t))break;
                	if(union(list.get(i).f,list.get(i).t)==1) {
                		k++;
                		loc=list.get(i).quan;
                	}
                }
                System.out.println(loc);
            }

        }
        class xi implements java.lang.Comparable<xi>{
            int f;
            int t;
            int quan;
            public int compareTo(xi o) {
                return this.quan-o.quan;
            }
            
            public xi(int f, int t, int quan) {
                super();
                this.f = f;
                this.t = t;
                this.quan = quan;
            }
            
        }