检查边长度限制的路径是否存在

/*
 * 思路：
 * 1. 对edgeList进行排序，按照边的长度从小到大排序。
 * 2. 使用并查集（Union-Find）数据结构来管理连接的点。
 * 3. 对queries进行排序，按照limit从小到大排序。
 * 4. 逐一处理查询，使用并查集来判断两个点是否在同一个集合内。
 */

import java.util.Arrays;
import java.util.stream.IntStream;

public class Solution {
    public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {
        Arrays.sort(edgeList, (a, b) -> a[2] - b[2]);
        int[] parent = IntStream.range(0, n).toArray();

        int[][] sortedQueries = IntStream.range(0, queries.length)
            .mapToObj(i -> new int[]{queries[i][0], queries[i][1], queries[i][2], i})
            .sorted((a, b) -> Integer.compare(a[2], b[2]))
            .toArray(int[][]::new);

        boolean[] answer = new boolean[queries.length];
        int edgeIndex = 0;
        for (int[] query : sortedQueries) {
            int u = query[0];
            int v = query[1];
            int limit = query[2];
            int queryIndex = query[3];

            while (edgeIndex < edgeList.length && edgeList[edgeIndex][2] < limit) {
                union(parent, edgeList[edgeIndex][0], edgeList[edgeIndex][1]);
                edgeIndex++;
            }

            answer[queryIndex] = find(parent, u) == find(parent, v);
        }

        return answer;
    }

    private int find(int[] parent, int x) {
        if (parent[x] != x) {
            parent[x] = find(parent, parent[x]);
        }
        return parent[x];
    }

    private void union(int[] parent, int x, int y) {
        int rootX = find(parent, x);
        int rootY = find(parent, y);
        if (rootX != rootY) {
            parent[rootX] = rootY;
        }
    }
}