Formatted question description: https://leetcode.ca/all/1627.html

# 1627. Graph Connectivity With Threshold (Hard)

We have `n`

cities labeled from `1`

to `n`

. Two different cities with labels `x`

and `y`

are directly connected by a bidirectional road if and only if `x`

and `y`

share a common divisor **strictly greater** than some `threshold`

. More formally, cities with labels `x`

and `y`

have a road between them if there exists an integer `z`

such that all of the following are true:

`x % z == 0`

,`y % z == 0`

, and`z > threshold`

.

Given the two integers, `n`

and `threshold`

, and an array of `queries`

, you must determine for each `queries[i] = [a`

if cities _{i}, b_{i}]`a`

and _{i}`b`

are connected (i.e. there is some path between them)._{i}

Return *an array *`answer`

*, where *`answer.length == queries.length`

* and *`answer[i]`

* is *`true`

* if for the *`i`

^{th}* query, there is a path between *`a`

_{i}* and *`b`

_{i}*, or *`answer[i]`

* is *`false`

* if there is no path.*

**Example 1:**

Input:n = 6, threshold = 2, queries = [[1,4],[2,5],[3,6]]Output:[false,false,true]Explanation:The divisors for each number: 1: 1 2: 1, 2 3: 1,34: 1, 2,45: 1,56: 1, 2,3,6Using the underlined divisors above the threshold, only cities 3 and 6 share a common divisor, so they are the only ones directly connected. The result of each query: [1,4] 1 is not connected to 4 [2,5] 2 is not connected to 5 [3,6] 3 is connected to 6 through path 3--6

**Example 2:**

Input:n = 6, threshold = 0, queries = [[4,5],[3,4],[3,2],[2,6],[1,3]]Output:[true,true,true,true,true]Explanation:The divisors for each number are the same as the previous example. However, since the threshold is 0, all divisors can be used. Since all numbers share 1 as a divisor, all cities are connected.

**Example 3:**

Input:n = 5, threshold = 1, queries = [[4,5],[4,5],[3,2],[2,3],[3,4]]Output:[false,false,false,false,false]Explanation:Only cities 2 and 4 share a common divisor 2 which is strictly greater than the threshold 1, so they are the only ones directly connected. Please notice that there can be multiple queries for the same pair of nodes [x, y], and that the query [x, y] is equivalent to the query [y, x].

**Constraints:**

`2 <= n <= 10`

^{4}`0 <= threshold <= n`

`1 <= queries.length <= 10`

^{5}`queries[i].length == 2`

`1 <= a`

_{i}, b_{i}<= cities`a`

_{i}!= b_{i}

**Related Topics**:

Math, Union Find

## Solution 1. Union Find

Intuition:

- If two numbers share the same factor, use union find to connect them.
- For each query, use union find to check if they are connected.

For #1, the brute force way is to check all combination pairs of cities which is `O(N^2)`

time complexity and will get TLE.

A more efficient way is to use similar idea as in Sieve of Eratosthenes.

For each number `i`

in `[1 + threshold, n]`

, we connect `i`

with multiples of `i`

(i.e. `2 * i, 3 * i, 4 * i, ...`

).

In the worst case where `threshold = 0`

, iterating all the city pairs cost `N + N / 2 + N / 3 + ... + 1 = N * (1 + 1 / 2 + 1 / 3 + ... + 1 / N)`

. `1 + 1 / 2 + 1 / 3 + ... + 1 / N`

is a harmonic series and bounded by `logN`

. So the iteration takes `O(NlogN)`

.

```
// OJ: https://leetcode.com/problems/graph-connectivity-with-threshold/
// Time: O(NlogN + Q)
// Space: O(N)
// Ref: https://leetcode.com/problems/graph-connectivity-with-threshold/discuss/899595/C%2B%2BJavaPython-Union-Find-O(N-*-logN-%2B-q)
class UnionFind {
vector<int> id;
public:
UnionFind(int n) : id(n) {
iota(begin(id), end(id), 0);
}
int find(int x) {
return id[x] == x ? x : (id[x] = find(id[x]));
}
void connect(int a, int b) {
int p = find(a), q = find(b);
if (p == q) return;
id[p] = q;
}
bool connected(int a, int b) {
return find(a) == find(b);
}
};
class Solution {
public:
vector<bool> areConnected(int n, int threshold, vector<vector<int>>& Q) {
unordered_map<int, int> m;
UnionFind uf(n);
for (int i = 1 + threshold; i <= n; ++i) {
for (int j = 2 * i; j <= n; j += i) {
uf.connect(i - 1, j - 1);
}
}
vector<bool> ans;
for (auto &q : Q) ans.push_back(uf.connected(q[0] - 1, q[1] - 1));
return ans;
}
};
```

Java

```
class Solution {
public List<Boolean> areConnected(int n, int threshold, int[][] queries) {
int[] parents = new int[n + 1];
for (int i = 1; i <= n; i++)
parents[i] = i;
int max = n / 2;
for (int i = threshold + 1; i <= max; i++) {
for (int j = i * 2; j <= n; j += i)
union(parents, i, j);
}
List<Boolean> list = new ArrayList<Boolean>();
for (int[] query : queries)
list.add(find(parents, query[0]) == find(parents, query[1]));
return list;
}
public void union(int[] parents, int index1, int index2) {
parents[find(parents, index1)] = find(parents, index2);
}
public int find(int[] parents, int index) {
while (parents[index] != index) {
parents[index] = find(parents, parents[index]);
index = parents[index];
}
return index;
}
}
```