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

题目：

给你一个 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 <= 109
两个点之间可能有 多条 边。

代码：

方法一——超时：
 

class Solution {
public:
    bool exist(vector<vector<int>>& matrix,int p,int q,int dis){
    if(p==q)return true;
    int n=matrix.size();
    bool res=false;

    for(int i=0;i<n;i++){
        if(matrix[p][i]!=INT_MAX){
            if(matrix[p][i]<dis){
                int temp=matrix[p][i];
                matrix[p][i]=INT_MAX;
                res|=exist(matrix,i,q,dis);
                matrix[p][i]=temp;
            }
        }
    }
    return res;
}

vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& edgeList, vector<vector<int>>& queries) {
    //建立图数据结构
    vector<vector<int>> matrix(n,vector<int>(n,INT_MAX));
    for(int i=0;i<edgeList.size();i++){
        int u=edgeList[i][0];
        int v=edgeList[i][1];
        int dis=edgeList[i][2];
        matrix[u][v]=min(matrix[u][v],dis);
        matrix[v][u]=min(matrix[v][u],dis);
    }
    //遍历图
    vector<bool> res;
    for(int i=0;i<queries.size();i++){
        //判断是否存在从p到q的路径
        int p=queries[i][0];
        int q=queries[i][1];
        int dis=queries[i][2];
        res.push_back(exist(matrix,p,q,dis));
    }
    //返回数组
    return res;
}
};

思路：就是普通的思路，实现。

代码：

方法二——并查集：

int pre[100005]; //并查集数组
int idx[100005];//queries排序索引
int idxel[100005];//edgeList排序索引
class Solution {
public:
    vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& edgeList, vector<vector<int>>& queries) {
        int m=queries.size(),M=edgeList.size();
        vector<bool> ret(m);
        for(int i=0;i<n;i++)
            pre[i]=i;
        for(int i=0;i<m;i++)
            idx[i]=i;
        for(int i=0;i<M;i++)
            idxel[i]=i;
        sort(idx,idx+m,[&](int x,int y){return queries[x][2]<queries[y][2];});
        sort(idxel,idxel+M,[&](int x,int y){return edgeList[x][2]<edgeList[y][2];});
        int curel=0;
        for(int i=0;i<m;i++){
            int x=queries[idx[i]][0],y=queries[idx[i]][1],limit=queries[idx[i]][2];
            while(curel<M&&edgeList[idxel[curel]][2]<limit){
                combine(edgeList[idxel[curel]][0],edgeList[idxel[curel]][1]);
                curel++;
            }
            ret[idx[i]] = find(x)==find(y);
        }
        return ret;
    }
    int find(int x) {
        return x == pre[x] ? x : pre[x]=find(pre[x]);
    }
    void combine(int x,int y){
        int py=find(y),px=find(x);
        if(py!=px){
            pre[py]=find(px);
        }
    }
};

思路：

首先观察 queries的数量级到了 1e5，所以每次查询开销不可能太大。优先想到用并查集查找两点是否连通。
那么如何考虑 limit 和边的权重呢？
我们可以将 queries 先按照 limit升序排序，先从 limit 小的 query 查询，这样只需要在查询前把比当前 limit小的 edge都连起来就可以了。
当然 edgeList 也需要事先按照边的权重排序。