力扣1627——带阈值的图连通性

1627. 带阈值的图连通性

有 n 座城市，编号从 1 到 n 。编号为 x 和 y 的两座城市直接连通的前提是： x 和 y 的公因数中，至少有一个 严格大于 某个阈值 threshold 。更正式地说，如果存在整数 z ，且满足以下所有条件，则编号 x 和 y 的城市之间有一条道路：

• x % z == 0
• y % z == 0
• z > threshold

给你两个整数 n 和 threshold ，以及一个待查询数组，请你判断每个查询 queries[i] = [ai, bi] 指向的城市 ai 和 bi 是否连通（即，它们之间是否存在一条路径）。

返回数组 answer ，其中answer.length == queries.length 。如果第 i 个查询中指向的城市 ai 和 bi 连通，则 answer[i] 为 true ；如果不连通，则 answer[i] 为 false 。

示例 1：

输入：n = 6, threshold = 2, queries = [[1,4],[2,5],[3,6]]
输出：[false,false,true]
解释：每个数的因数如下：
1:   1
2:   1, 2
3:   1, 3
4:   1, 2, 4
5:   1, 5
6:   1, 2, 3, 6
所有大于阈值的的因数已经加粗标识，只有城市 3 和 6 共享公约数 3 ，因此结果是： 
[1,4]   1 与 4 不连通
[2,5]   2 与 5 不连通
[3,6]   3 与 6 连通，存在路径 3--6

示例 2：

输入：n = 6, threshold = 0, queries = [[4,5],[3,4],[3,2],[2,6],[1,3]]
输出：[true,true,true,true,true]
解释：每个数的因数与上一个例子相同。但是，由于阈值为 0 ，所有的因数都大于阈值。因为所有的数字共享公因数 1 ，所以所有的城市都互相连通。

示例 3：

输入：n = 5, threshold = 1, queries = [[4,5],[4,5],[3,2],[2,3],[3,4]]
输出：[false,false,false,false,false]
解释：只有城市 2 和 4 共享的公约数 2 严格大于阈值 1 ，所以只有这两座城市是连通的。
注意，同一对节点 [x, y] 可以有多个查询，并且查询 [x，y] 等同于查询 [y，x] 。

提示：

• 2 <= n <= 104
• 0 <= threshold <= n
• 1 <= queries.length <= 105
• queries[i].length == 2
• 1 <= ai, bi <= cities
• ai != bi

题解

这道题最开始的时候使用并查集+最大公因数，判断任何两个点的最大公因数，如果大于阈值，则使用并查集连在一起，但是这样的结果是超时的。
后来就考虑别的思路，首先小于等于阈值的城市不需要考虑肯定是各自不连通的，对于大于阈值的城市，可以想到如果对于一个i,i>thershold，
那么所有i的倍数和i一定也是相连的，因此可以从这个角度进行考虑，那么遍历所有的基数和其倍数就可以了，那么现在的关键就是如何找基数。
首先第一个基数肯定是threshold+1，那么下一个基数一定没有被访问过，也就是不是前面基数的倍数，因为如果是前面基数的倍数，则该数的倍数
一定是前面基数倍数的子集。通过这样的方法进行并查集操作，最后顺利通过。

代码

class Solution {
public:

    #define N  10000 + 10
    int fa[N];
    


    int find(int x){
        if(fa[x] == x) return x;
        else return fa[x] = find(fa[x]);
    }

    vector<bool> areConnected(int n, int threshold, vector<vector<int>>& queries) {
        


        for(int i = 0 ; i <= n; i++ ) fa[i] = i;

        bool flag[N];
        memset(flag,0,sizeof(flag));

        for(int i = threshold + 1; i <= n; i++){
            if(flag[i]) continue;
            flag[i] = true;
            for(int j = 1; i * j <= n; j++){
                int fi = find(i);
                int fj = find(i*j);
                fa[fj] = fi;
                flag[i*j] = true;
            }
        }



        vector<bool> ans;
        for(auto v:queries){
            int fx = find(v[0]);
            int fy = find(v[1]);
            if(fx == fy) ans.push_back(true);
            else ans.push_back(false);
        }
        return ans;

    }
};