JAVA程序设计：检查边长度限制的路径是否存在（LeetCode：5632）

给你一个 n 个点组成的无向图边集 edgeList ，其中 edgeList[i] = [ui, vi, disi] 表示点 ui 和点 vi 之间有一条长度为 disi 的边。请注意，两个点之间可能有 超过一条边 。

给你一个查询数组queries ，其中 queries[j] = [pj, qj, limitj] ，你的任务是对于每个查询 queries[j] ，判断是否存在从 pj 到 qj 的路径，且这条路径上的每一条边都 严格小于 limitj 。

请你返回一个 布尔数组 answer ，其中 answer.length == queries.length ，当 queries[j] 的查询结果为 true 时， answer 第 j 个值为 true ，否则为 false 。

示例 1：

输入：n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
输出：[false,true]
解释：上图为给定的输入数据。注意到 0 和 1 之间有两条重边，分别为 2 和 16 。
对于第一个查询，0 和 1 之间没有小于 2 的边，所以我们返回 false 。
对于第二个查询，有一条路径（0 -> 1 -> 2）两条边都小于 5 ，所以这个查询我们返回 true 。
示例 2：

输入：n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
输出：[true,false]
解释：上图为给定数据。

提示：

2 <= n <= 105
1 <= edgeList.length, queries.length <= 105
edgeList[i].length == 3
queries[j].length == 3
0 <= ui, vi, pj, qj <= n - 1
ui != vi
pj != qj
1 <= disi, limitj <= 10^9
两个点之间可能有 多条 边。

思路：我们考虑将所有查询按照边的要求从小到大排序，然后对边的权值从小到大排序，对于当前查询，我们将所有能够满足当前limit限制的边通过并查集建立联系，之后判断查询的两个点是否在一个集合中即可。

class Solution {

    private int[] f;

    public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {

        int m = edgeList.length;
        int num = queries.length;

        f = new int[n];
        int[][] q = new int[num][2];
        boolean[] ans = new boolean[num];

        for (int i = 0; i < n; i++)
            f[i] = i;
        for (int i = 0; i < num; i++) {
            q[i][0] = queries[i][2];
            q[i][1] = i;
        }

        int p = 0;
        Arrays.sort(q, (a, b) -> a[0] - b[0]);
        Arrays.sort(edgeList, (a, b) -> (a[2] - b[2]));

        for (int i = 0; i < num; i++) {
            int t1, t2;
            int index = q[i][1], limit = q[i][0];
            while (p < m && edgeList[p][2] < limit) {
                t1 = find(edgeList[p][0]);
                t2 = find(edgeList[p++][1]);
                if (t1 != t2)
                    f[t1] = t2;
            }
            t1 = find(queries[index][0]);
            t2 = find(queries[index][1]);
            if (t1 != t2)
                ans[index] = false;
            else
                ans[index] = true;
        }
        return ans;
    }

    private int find(int x) {
        if (f[x] == x)
            return x;
        return f[x] = find(f[x]);
    }
}