Find number of square of area Z which can be built in a matrix having blocked regions

In an N * N matrix, certain rows and columns are blocked. Find the number of squares of area Z which can be built in such a matrix with the given constraints: 

1. Every cell will contribute 1 unit area and 1 cell belongs to exactly 1 sub – grid.
2. All cells should be unblocked cell.

The blocked rows and columns are represented by two arrays row[] and col[].
Examples:

Input: N = 8, Z = 4, row[] = {4, 6}, col[] = {3, 8} 
Output: 6 
Here is the required matrix: 
1 1 X 2 2 2 2 X 
1 1 X 2 2 2 2 X 
1 1 X 2 2 2 2 X 
X X X X X X X X 
3 3 X 4 4 4 4 X 
X X X X X X X X 
5 5 X 6 6 6 6 X 
5 5 X 6 6 6 6 X 
Where X represents blocked cells. 1 – 6 represents unblocked rectangular regions. 
Contribution to answer is as given : 
Region 1: 1 region with area 4 
Region 2: 2 regions with area 4 
Region 3: No region with area 4 
Region 4: No region with area 4 
Region 5: 1 region with area 4 
Region 6: 2 regions with area 4 

Approach:

• Here, the actual matrix will be divided into several rectangles. Regions can only be built in these rectangles. Suppose there exists a rectangle with dimensions R * L then the number of regions of area Z will be equal to (R / K) * (L / K) where K is the square root of Z because maximum square of dimension K which can fit in length L is L / K and same goes for the width. So, the task is to find the dimensions of all such rectangles and calculate the number of areas possible in it.
• To find the rectangles, first all the blocked rows and columns are already given in sorted order. Now, consider the region between the first blocked row and the first blocked column. This region is entirely unblocked. Similarly, a region between any two consecutive blocked column along with any two consecutive blocked row will form an unblocked region.
• So, basically any unblocked region will lie between any two consecutive blocked rows and any two consecutive blocked columns. We can store length between consecutive blocked rows and consecutive blocked columns and then we can take any length from row array and any length from column array and multiply them.
• Find all these unblocked regions and sum the number of squares of size K * K possible to fit in total.

Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to calculate the number of
// square areas of size K*K
int subgrids(int N, int Z, int row[],
             int col[], int r, int c)
{
    // Row array and column array to
    // store the lengths of differences
    // between consecutive rows/columns
    vector<int> conrow;
    vector<int> concol;

    int K = sqrt(Z);

    // Fill the conrow vector
    conrow.push_back(row[0] - 0 - 1);
    conrow.push_back(N + 1 - row[r - 1] - 1);
    for (int i = 1; i < r; i++) {
        conrow.push_back(row[i] - row[i - 1] - 1);
    }

    // Fill the concol vector
    concol.push_back(col[0] - 0 - 1);
    concol.push_back(N + 1 - col - 1);
    for (int i = 1; i < c; i++) {
        concol.push_back(col[i] - col[i - 1] - 1);
    }

    int row_size = conrow.size();
    int col_size = concol.size();

    // To store the required answer
    int answer = 0;

    // Every pair of row size and column size
    // would result in an unblocked region
    for (int i = 0; i < row_size; i++) {
        for (int j = 0; j < col_size; j++) {
            int total = (concol[j] / K)
                        * (conrow[i] / K);
            answer += (total);
        }
    }

    return answer;
}

// Driver code
int main()
{
    int N = 8, Z = 4;
    int row[] = { 4, 6 };
    int col[] = { 3, 8 };
    int r = sizeof(row) / sizeof(row[0]);
    int c = sizeof(col) / sizeof(col[0]);

    cout << subgrids(N, Z, row, col, r, c);

    return 0;
}

Java

// Java implementation of the approach
import java.util.*;

class GFG
{

// Function to calculate the number of
// square areas of size K*K
static int subgrids(int N, int Z, int row[],
                    int col[], int r, int d)
{
    // Row array and column array to
    // store the lengths of differences
    // between consecutive rows/columns
    Vector<Integer> conrow = new Vector<Integer>();
    Vector<Integer> concol = new Vector<Integer>();

    int K = (int) Math.sqrt(Z);

    // Fill the conrow vector
    conrow.add(row[0] - 0 - 1);
    conrow.add(N + 1 - row[r - 1] - 1);
    for (int i = 1; i < r; i++)
    {
        conrow.add(row[i] - row[i - 1] - 1);
    }

    // Fill the concol vector
    concol.add(col[0] - 0 - 1);
    concol.add(N + 1 - col[d - 1] - 1);
    for (int i = 1; i < d; i++)
    {
        concol.add(col[i] - col[i - 1] - 1);
    }

    int row_size = conrow.size();
    int col_size = concol.size();

    // To store the required answer
    int answer = 0;

    // Every pair of row size and column size
    // would result in an unblocked region
    for (int i = 0; i < row_size; i++)
    {
        for (int j = 0; j < col_size; j++)
        {
            int total = (concol.get(j) / K) *
                        (conrow.get(i) / K);
            answer += (total);
        }
    }
    return answer;
}

// Driver code
public static void main(String[] args)
{
    int N = 8, Z = 4;
    int row[] = { 4, 6 };
    int col[] = { 3, 8 };
    int r = row.length;
    int d = col.length;

    System.out.print(subgrids(N, Z, row, col, r, d));
}
}

// This code is contributed by PrinciRaj1992

Python3

# Python3 implementation of the approach
from math import sqrt

# Function to calculate the number of
# square areas of size K*K
def subgrids(N, Z, row, col, r, d) :

    # Row array and column array to
    # store the lengths of differences
    # between consecutive rows/columns
    conrow = [];
    concol = [];

    K = int(sqrt(Z));

    # Fill the conrow vector
    conrow.append(row[0] - 0 - 1)
    conrow.append(N + 1 - row[r - 1] - 1)

    for i in range(1, r) :
        conrow.append(row[i] - row[i - 1] - 1);

    # Fill the concol vector
    concol.append(col[0] - 0 - 1)
    concol.append(N + 1 - col[d - 1] - 1)

    for i in range(1, d) :
        concol.append(col[i] - col[i - 1] - 1);

    row_size = len(conrow)
    col_size = len(concol)

    # To store the required answer
    answer = 0

    # Every pair of row size and column size
    # would result in an unblocked region
    for i in range(row_size) :
        for j in range(col_size) :
            total = (concol[j] // K) * \
                    (conrow[i] // K)
            answer += (total)

    return answer

# Driver code
if __name__ == "__main__" :

    N = 8; Z = 4
    row = [ 4, 6 ]
    col = [ 3, 8 ]
    r = len(row)
    d = len(col)

    print(subgrids(N, Z, row, col, r, d))

# This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;
using System.Collections.Generic;

class GFG
{

// Function to calculate the number of
// square areas of size K*K
static int subgrids(int N, int Z, int []row,
                    int []col, int r, int d)
{
    // Row array and column array to
    // store the lengths of differences
    // between consecutive rows/columns
    List<int> conrow = new List<int>();
    List<int> concol = new List<int>();

    int K = (int) Math.Sqrt(Z);

    // Fill the conrow vector
    conrow.Add(row[0] - 0 - 1);
    conrow.Add(N + 1 - row[r - 1] - 1);
    for (int i = 1; i < r; i++)
    {
        conrow.Add(row[i] - row[i - 1] - 1);
    }

    // Fill the concol vector
    concol.Add(col[0] - 0 - 1);
    concol.Add(N + 1 - col[d - 1] - 1);
    for (int i = 1; i < d; i++)
    {
        concol.Add(col[i] - col[i - 1] - 1);
    }

    int row_size = conrow.Count;
    int col_size = concol.Count;

    // To store the required answer
    int answer = 0;

    // Every pair of row size and column size
    // would result in an unblocked region
    for (int i = 0; i < row_size; i++)
    {
        for (int j = 0; j < col_size; j++)
        {
            int total = (concol[j] / K) *
                        (conrow[i] / K);
            answer += (total);
        }
    }
    return answer;
}

// Driver code
public static void Main(String[] args)
{
    int N = 8, Z = 4;
    int []row = { 4, 6 };
    int []col = { 3, 8 };
    int r = row.Length;
    int d = col.Length;

    Console.Write(subgrids(N, Z, row, col, r, d));
}
}

// This code is contributed by Rajput-Ji

Javascript

<script>

// Javascript implementation of the approach

// Function to calculate the number of
// square areas of size K*K
function subgrids(N, Z, row, col, r, c)
{
    // Row array and column array to
    // store the lengths of differences
    // between consecutive rows/columns
    var conrow = [];
    var concol = [];

    var K = Math.sqrt(Z);

    // Fill the conrow vector
    conrow.push(row[0] - 0 - 1);
    conrow.push(N + 1 - row[r - 1] - 1);
    for (var i = 1; i < r; i++) {
        conrow.push(row[i] - row[i - 1] - 1);
    }

    // Fill the concol vector
    concol.push(col[0] - 0 - 1);
    concol.push(N + 1 - col - 1);
    for (var i = 1; i < c; i++) {
        concol.push(col[i] - col[i - 1] - 1);
    }

    var row_size = conrow.length;
    var col_size = concol.length;

    // To store the required answer
    var answer = 0;

    // Every pair of row size and column size
    // would result in an unblocked region
    for (var i = 0; i < row_size; i++) {
        for (var j = 0; j < col_size; j++) {
            var total = parseInt(concol[j] / K)
                        * parseInt(conrow[i] / K);
            answer += (total);
        }
    }

    return answer;
}

// Driver code
var N = 8, Z = 4;
var row = [4, 6];
var col = [3, 8];
var r = row.length;
var c = col.length;
document.write( subgrids(N, Z, row, col, r, c));

</script>

Output:

6

Time Complexity: O(r * c)

Auxiliary Space: O(r * c)