蓝桥杯  历届试题 国王的烦恼 并查集 逆序加边

 历届试题 国王的烦恼  

时间限制：1.0s   内存限制：256.0MB

问题描述

　　C国由n个小岛组成，为了方便小岛之间联络，C国在小岛间建立了m座大桥，每座大桥连接两座小岛。两个小岛间可能存在多座桥连接。然而，由于海水冲刷，有一些大桥面临着不能使用的危险。

　　如果两个小岛间的所有大桥都不能使用，则这两座小岛就不能直接到达了。然而，只要这两座小岛的居民能通过其他的桥或者其他的小岛互相到达，他们就会安然无事。但是，如果前一天两个小岛之间还有方法可以到达，后一天却不能到达了，居民们就会一起抗议。

　　现在C国的国王已经知道了每座桥能使用的天数，超过这个天数就不能使用了。现在他想知道居民们会有多少天进行抗议。

输入格式

　　输入的第一行包含两个整数n, m，分别表示小岛的个数和桥的数量。
　　接下来m行，每行三个整数a, b, t，分别表示该座桥连接a号和b号两个小岛，能使用t天。小岛的编号从1开始递增。

输出格式

　　输出一个整数，表示居民们会抗议的天数。

样例输入

4 4
1 2 2
1 3 2
2 3 1
3 4 3

样例输出

2

样例说明

　　第一天后2和3之间的桥不能使用，不影响。
　　第二天后1和2之间，以及1和3之间的桥不能使用，居民们会抗议。
　　第三天后3和4之间的桥不能使用，居民们会抗议。

数据规模和约定

　　对于30%的数据，1<=n<=20，1<=m<=100；
　　对于50%的数据，1<=n<=500，1<=m<=10000；
　　对于100%的数据，1<=n<=10000，1<=m<=100000，1<=a, b<=n， 1<=t<=100000。

吐槽:感觉这出题人并没有好好说清楚题意,不连通了到底是抗议一天，还是之后每天都抗议呢，那个样例也不能说明这点，不过嘛，正确的理解是前者，但是我觉得题目应该说是抗议的次数而不是天数,这题数据规模很大，c++用并查集可以过，java会超时，数据没给好，java应该给2s的，逆序加边，当它变成一颗最小生成树就break,感觉这算法就是最小生成树的kruskal算法思想，不过主要是并查集实现

这里也可以用哈希表统计抗议天数，注意java不能AC,用c++

import java.util.Arrays;
import java.util.Scanner;

public class 蓝桥杯_国王的烦恼 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
		m = in.nextInt();
		f = new int[n+5];
		g = new Edge[m+5];
			
		for(int i=1;i<=n;i++)
			f[i] = i;
		
		for(int i=0;i<m;i++)
			g[i] = new Edge(in.nextInt(),in.nextInt(),in.nextInt());
		
		Arrays.sort(g,0,m);
		
		for(int i=0;i<m;i++) {
			if(union(g[i].a,g[i].b)) {
				if(x!=g[i].w) {
					ans++;
					x=g[i].w;
				}
			}
			if(cnt==n-1) {
				System.out.println(ans);
				break;
			}	
		}
		
	}
	
	static int n,m,cnt=0,ans=0,x=0;
	static int[] f;
	static Edge[] g;
	
	static int find(int x) {
		if(f[x]==x)
			return x;
		return f[x] = find(f[x]);
	}
	
	static boolean union(int x,int y) {
		int a = find(x);
		int b = find(y);
		if(a!=b) {
			f[a] = b;
			cnt++;
			return true;
		}
		return false;
	}
	
	static class Edge implements Comparable<Edge>{
		int a,b,w;
		public Edge(int a,int b,int w) {
			this.a = a;
			this.b = b;
			this.w = w;
		}

		@Override
		public int compareTo(Edge e) {
			return e.w - this.w;//大->小
		}
		
	}

}