3532. Path Existence Queries in a Graph I

class Solution {
    public boolean[] pathExistenceQueries(int n, int[] nums, int maxDiff, int[][] queries) {
        int[] component = new int[n];
        int id = 0;
        component[0] = 0;

        for (int i = 1; i < n; i++) {
            if (nums[i] - nums[i - 1] > maxDiff) {
                id++;
            }
            component[i] = id;
        }

        boolean[] ans = new boolean[queries.length];
        for (int i = 0; i < queries.length; i++) {
            ans[i] = component[queries[i][0]] == component[queries[i][1]];
        }

        return ans;
    }
}

class Solution:
    def pathExistenceQueries(self, n, nums, maxDiff, queries):

        component = [0] * n
        comp_id = 0

        for i in range(1, n):
            if nums[i] - nums[i - 1] > maxDiff:
                comp_id += 1
            component[i] = comp_id

        ans = []

        for u, v in queries:
            ans.append(component[u] == component[v])

        return ans

class Solution {
public:
    vector<bool> pathExistenceQueries(int n, vector<int>& nums, int maxDiff, vector<vector<int>>& queries) {

        vector<int> component(n);
        int id = 0;

        for (int i = 1; i < n; i++) {
            if (nums[i] - nums[i - 1] > maxDiff) {
                id++;
            }
            component[i] = id;
        }

        vector<bool> ans;

        for (auto &q : queries) {
            ans.push_back(component[q[0]] == component[q[1]]);
        }

        return ans;
    }
};

var pathExistenceQueries = function(n, nums, maxDiff, queries) {

    const component = new Array(n).fill(0);
    let id = 0;

    for (let i = 1; i < n; i++) {
        if (nums[i] - nums[i - 1] > maxDiff) {
            id++;
        }
        component[i] = id;
    }

    const ans = [];

    for (const [u, v] of queries) {
        ans.push(component[u] === component[v]);
    }

    return ans;
};