Graph Connectivity With Threshold

This page explains Java solution to problem Graph Connectivity With Threshold using Union And Find algorithm.

Problem Statement

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] = [ai, bi] if cities ai and bi are connected (i.e. there is some path between them).

Return an array answer, where answer.length == queries.length and answer[i] is true if for the ith query, there is a path between ai and bi, or answer[i] is false if there is no path.

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, 3
4: 1, 2, 4
5: 1, 5
6: 1, 2, 3, 6
Using 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

Input: n = 6, threshold = 0, queries = [[4,5],[3,4],[3,2],[2,6],[1,3]]
Output: [true,true,true,true,true]

Input: n = 5, threshold = 1, queries = [[4,5],[4,5],[3,2],[2,3],[3,4]]
Output: [false,false,false,false,false]

Solution

package com.vc.hard;

import java.util.ArrayList;
import java.util.List;

class GraphConnectivityWithThreshold {
    public List<Boolean> areConnected(int n, int threshold, int[][] queries) {
        if(queries == null) return new ArrayList<>();

        int[] parent = new int[n + 1];
        for(int i = 0; i <= n; i++) parent[i] = i;

        for(int i = threshold + 1; i <= n; i++) {
            for(int j = i; j <= n; j+=i) {
                int iParent = find(i, parent);
                int jParent = find(j, parent);
                parent[iParent] = jParent;
            }
        }

        List<Boolean> res = new ArrayList<>();
        for(int[] query: queries) {
            int xParent = find(query[0], parent);
            int yParent = find(query[1], parent);
            res.add(xParent == yParent);
        }
        return res;
    }

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

Time Complexity

O(N log N + Q) Where
N is total number of cities
Q is total number of queries

Space Complexity

O(N + Q) Where
N is total number of cities
Q is total number of queries