Queries to find the count of connected Non-Empty Cells in a Matrix with updates

// Java program to implement
// the above approach
import java.util.*;

class GFG{

// Count of connected cells
static int ctr = 0;

// Function to return the representative
// of the Set to which x belongs
static int find(int []parent, int x)
{
    
    // If x is parent of itself
    if (parent[x] == x)

        // x is representative
        // of the Set
        return x;

    // Otherwise
    parent[x] = find(parent, parent[x]);

    // Path Compression
    return parent[x];
}

// Unites the set that includes
// x and the set that includes y
static void setUnion(int[] parent,
                     int[] rank, int x, int y)
{
    
    // Find the representatives(or the
    // root nodes) for x an y
    int parentx = find(parent, x);
    int parenty = find(parent, y);

    // If both are in the same set
    if (parenty == parentx)
        return;

    // Decrement count
    ctr--;

    // If x's rank is less than y's rank
    if (rank[parentx] < rank[parenty])
    {
        parent[parentx] = parenty;
    }

    // Otherwise
    else if (rank[parentx] > rank[parenty])
    {
        parent[parenty] = parentx;
    }
    else 
    {
        
        // Then move x under y (doesn't matter
        // which one goes where)
        parent[parentx] = parenty;

        // And increment the result tree's
        // rank by 1
        rank[parenty]++;
    }
}

// Function to count the number of
// connected cells in the matrix
static int [] solve(int n, int m,
                    int [][]query)
{
    
    // Store result for queries
    int []result = new int[query.length];
    
    // Store representative of
    // each element
    int []parent = new int[n * m];

    // Initially, all elements
    // are in their own set
    for(int i = 0; i < n * m; i++)
        parent[i] = i;

    // Stores the rank(depth) of each node
    int []rank = new int[n * m];
    Arrays.fill(rank, 1);
    
    boolean []grid = new boolean[n * m];

    for(int i = 0; i < query.length; i++)
    {
        int x = query[i][0];
        int y = query[i][1];

        // If the grid[x*m + y] is already
        // set, store the result
        if (grid[m * x + y] == true)
        {
            result[i] = ctr;
            continue;
        }

        // Set grid[x*m + y] to 1
        grid[m * x + y] = true;

        // Increment count.
        ctr++;

        // Check for all adjacent cells
        // to do a Union with neighbour's
        // set if neighbour is also 1
        if (x > 0 && grid[m * (x - 1) + y] == true)
            setUnion(parent, rank,
                     m * x + y, m * (x - 1) + y);

        if (y > 0 && grid[m * (x) + y - 1] == true)
            setUnion(parent, rank,
                     m * x + y, m * (x) + y - 1);

        if (x < n - 1 && grid[m * (x + 1) + y] == true)
            setUnion(parent, rank,
                     m * x + y, m * (x + 1) + y);

        if (y < m - 1 && grid[m * (x) + y + 1] == true)
            setUnion(parent, rank,
                     m * x + y, m * (x) + y + 1);

        // Store result.
        result[i] = ctr;
    }
    return result;
}

// Driver Code
public static void main(String[] args)
{
    int N = 3, M = 3, K = 4;

    int [][]query = { { 0, 0 },
                      { 1, 1 },
                      { 1, 0 },
                      { 1, 2 } };
    int[] result = solve(N, M, query);

    for(int i = 0; i < K; i++)
        System.out.print(result[i] + " ");
}
}

// This code is contributed by Amit Katiyar