leetcode-5632. 检查边长度限制的路径是否存在【离线+并查集】

最新推荐文章于 2022-12-16 14:05:14 发布

哇-WA

最新推荐文章于 2022-12-16 14:05:14 发布

阅读量175

点赞数

分类专栏：数据结构~并查集 leetcode

本文链接：https://blog.csdn.net/u013852115/article/details/111426702

版权

leetcode 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

数据结构~并查集

7 篇文章 0 订阅

订阅专栏

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

思路

按照离线的思想先把询问按照limit从小到大排序，这样我们并查集添边的时候就可以很容易的利用上一次询问时建立的模型，多次询问中就不需要重新添加上一次询问已经添加的边。

代码

class Solution {
public:
    static const int MAXN = 100005;
    struct edge
    {
        int u,v,val;
        bool operator<(const edge &a)const
        {
            return val<a.val;
        }
    }e[MAXN];
    struct query
    {
        int u,v,k,id;
        bool operator<(const query &a)const
        {
            return k<a.k;
        }
    }q[MAXN];
    int pre[MAXN];
    int find(int u)
    {
        if(pre[u]==u) return u;
        return pre[u]=find(pre[u]);
    }
    void merge(int u,int v)
    {
        int f1=find(u);
        int f2=find(v);
        if(f1!=f2)
            pre[f2]=f1;
    }
    vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& edgeList, vector<vector<int>>& queries) {
        for(int i=0;i<edgeList.size();i++)
        {
            e[i].u=edgeList[i][0];
            e[i].v=edgeList[i][1];
            e[i].val=edgeList[i][2];
        }
        sort(e,e+edgeList.size());
        for(int i=0;i<queries.size();i++)
        {
            q[i].u=queries[i][0];
            q[i].v=queries[i][1];
            q[i].k=queries[i][2];
            q[i].id=i;
        }
        sort(q,q+queries.size());
        vector<bool> ans(queries.size());
        for(int i=0;i<n;i++) pre[i]=i;
        int last=0;
        for(int i=0;i<queries.size();i++)
        {
            for(int j=last;j<edgeList.size();j++)
            {
                last=j;
                if(e[j].val>=q[i].k) break;
                merge(e[j].u,e[j].v);
            }
            ans[q[i].id]=(find(q[i].u)==find(q[i].v));
        }
        return ans;
    }
};