历届试题 国王的烦恼

@ 蓝桥杯 练习系统 历届试题 PREV-22

资源限制

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

---

问题描述

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

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

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

---

输入格式

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

---

输出格式

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

---

测试样例

Input：
4 4
1 2 2
1 3 2
2 3 1
3 4 3

Output：
2

Explanation：
第一天后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。

---

ACcode：

import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.PriorityQueue;
import java.util.Queue;

public class Main {

    static int[] link;

    public static void main(String[] args) {
        InputReader in = new InputReader(System.in, " ");
        int n = in.nextInt(), m = in.nextInt(), v, w, cnt = 1, time;
        Queue<Edge> queue = new PriorityQueue(m);
        link = new int[n + 1];
        while (m-- > 0)
            queue.offer(new Edge(in.nextInt(), in.nextInt(), in.nextInt()));
        for (int i = 1; i <= n; i++) link[i] = i;
        Edge now = queue.poll();
        link[now.w] = now.v;
        time = now.time;
        while (queue.size() > 0) {
            now = queue.poll();
            v = find(now.v);
            w = find(now.w);
            if (v == w) continue;
            link[w] = v;
            if (now.time < time) {
                cnt++;
                time = now.time;
            }
        }
        System.out.print(cnt);
    }

    static int find(int n) {
        if (link[n] == n) return n;
        return link[n] = find(link[n]);
    }

    static class Edge implements Comparable<Edge> {

        int v, w, time;

        Edge(int v, int w, int time) {
            this.v = v;
            this.w = w;
            this.time = time;
        }

        public int compareTo(Edge e) {
            return e.time - this.time;
        }
    }

    static class InputReader {

        BufferedReader read;
        StringTokenizer tok;
        String delimiters;

        InputReader(InputStream in) { this(in, " \n\t\r\f"); }

        InputReader(InputStream in, String delimiters) {
            this.read = new BufferedReader(new InputStreamReader(in));
            this.tok = new StringTokenizer("", this.delimiters = delimiters);
        }

        String next() {
            while (!tok.hasMoreTokens())
                try {
                    tok = new StringTokenizer(read.readLine(), delimiters);
                } catch (IOException e) { }
            return tok.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
    }
}

纯粹按该题描述来思考，我能想到的就是累加成超时的搜索，但将题目翻转过来就是道并查集，思路到了也就没啥好说的了