Find the number of p-sided squares in a grid with K blacks painted

Given a grid of size H*W with all cells initially white. Given N pairs (i, j) in an array, for each pair, paint cell (i, j) with black colour. The task is to determine how many squares of size p×p of the grid contains exactly K black cells, after N cells being painted.

Examples: 

Input: H = 4, W = 5,
      N = 8, K = 4, p = 3 
      arr=[ (3, 1), (3, 2), (3, 4), (4, 4), 
            (1, 5), (2, 3), (1, 1), (1, 4) ]
Output: 4
Cells the are being painted are shown in the figure below:
Here p = 3. 
There are six subrectangles of size 3*3. 
Two of them contain three black cells each, 
and the remaining four contain four black cells each.


Input: H = 1, W = 1, 
       N = 1, K = 1, p = 1
       arr=[ (1, 1) ]
Output: 1

Approach:

  • First thing to observe is that one p*p sub-grid will be different from the other if their starting points are different.
  • Second thing is that if the cell is painted black, it will contribute to p^2 different p*p sub-grids.
  • For example, suppose cell [i, j] is painted black. Then it will contribute additional +1 to all the subgrids having starting point
    [i-p+1][j-p+1] to [i, j].
  • Since there can be at most N blacks, for each black cell do p*p iterations and update its contribution for each p*p sub-grids.
  • Keep a map to keep track of answer for each cell of the grid.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to check if a cell is safe or not
bool isSafe(int x, int y, int h, int w, int p)
{
    if (x >= 1 and x <= h) {
        if (y >= 1 and y <= w) {
            if (x + p - 1 <= h) {
                if (y + p - 1 <= w) {
                    return true;
                }
            }
        }
    }
    return false;
}
  
// Function to print the number of p-sided squares 
// having k blacks
void CountSquares(int h, int w, int n, int k,
        int p, vector<pair<int, int> > painted)
{
    // Map to keep track for each cell that is
    // being affected by other blacks
    map<pair<int, int>, int> mp;
    for (int i = 0; i < painted.size(); ++i) {
        int x = painted[i].first;
        int y = painted[i].second;
  
        // For a particular row x and column y, 
        // it will affect all the cells starting
        // from row = x-p+1 and column = y-p+1 
        // and ending at x, y
        // hence there will be total 
        // of p^2 different cells
        for (int j = x - p + 1; j <= x; ++j) {
            for (int k = y - p + 1; k <= y; ++k) {
  
                // If the cell is safe
                if (isSafe(j, k, h, w, p)) {
                    pair<int, int> temp = { j, k };
  
                    // No need to increase the value
                    // as there is no sense of paint 
                    // 2 blacks in one cell
                    if (mp[temp] >= p * p)
                        continue; 
                    else
                        mp[temp]++;
                }
            }
        }
    }
  
    // Answer array to store the answer.
    int ans[p * p + 1]; 
    memset(ans, 0, sizeof ans);
    for (auto& x : mp) {
        int cnt = x.second;
        ans[cnt]++;
    }
  
    // sum variable to store sum for all the p*p sub
    // grids painted with 1 black, 2 black, 
    // 3 black, ..., p^2 blacks,
    // Since there is no meaning in painting p*p sub
    // grid with p^2+1 or more blacks
    int sum = 0; 
    for (int i = 1; i <= p * p; ++i)
        sum = sum + ans[i];
  
    // There will be total of 
    // (h-p+1) * (w-p+1), p*p sub grids
    int total = (h - p + 1) * (w - p + 1); 
    ans[0] = total - sum;
    cout << ans[k] << endl;
    return;
}
  
// Driver code
int main()
{
    int H = 4, W = 5, N = 8, K = 4, P = 3;
    vector<pair<int, int> > painted;
  
    // Initializing matrix
    painted.push_back({ 3, 1 });
    painted.push_back({ 3, 2 });
    painted.push_back({ 3, 4 });
    painted.push_back({ 4, 4 });
    painted.push_back({ 1, 5 });
    painted.push_back({ 2, 3 });
    painted.push_back({ 1, 1 });
    painted.push_back({ 1, 4 });
  
    CountSquares(H, W, N, K, P, painted);
    return 0;
}

chevron_right






                        filter_none









Python3





# Python3 implementation of the above approach


# Function to check if a cell is safe or not

def isSafe(x, y, h, w, p):

	if (x >= 1 and x <= h):
		if (y >= 1 and y <= w):
			if (x + p - 1 <= h):
				if (y + p - 1 <= w):
					return True
	return False

# Function to prthe number of p-sided squares
# having k blacks
def CountSquares(h, w, n, k, p, painted):
    
	# Map to keep track for each cell that is
	# being affected by other blacks
	mp = dict()
	for i in range(len(painted)):
		x = painted[i][0]
		y = painted[i][1]

		# For a particular row x and column y,
		# it will affect all the cells starting
		# from row = x-p+1 and column = y-p+1
		# and ending at x, y
		# hence there will be total
		# of p^2 different cells
		for j in range(x - p + 1, x + 1):
			for k in range(y - p + 1, y + 1):

				# If the cell is safe
				if (isSafe(j, k, h, w, p)):
					temp = (j, k)

					# No need to increase the value
					# as there is no sense of pa
					# 2 blacks in one cell
					if (temp in mp.keys() and mp[temp] >= p * p):

						continue

					else:

						mp[temp] = mp.get(temp, 0) + 1


	# Answer array to store the answer.

	ans = [0 for i in range(p * p + 1)]


	# memset(ans, 0, sizeof ans)

	for x in mp:

		cnt = mp[x]

		ans[cnt] += 1


	# Sum variable to store Sum for all the p*p sub

	# grids painted with 1 black, 2 black,

	# 3 black, …, p^2 blacks,

	# Since there is no meaning in painting p*p sub

	# grid with p^2+1 or more blacks

	Sum = 0

	for i in range(1, p * p + 1):

		Sum = Sum + ans[i]


	# There will be total of

	# (h-p+1) * (w-p+1), p*p sub grids

	total = (h – p + 1) * (w – p + 1)

	ans[0] = total – Sum

	print(ans[k])

	return


# Driver code

H = 4

W = 5

N = 8

K = 4

P = 3

painted = []


# Initializing matrix

painted.append([ 3, 1 ])

painted.append([ 3, 2 ])

painted.append([ 3, 4 ])

painted.append([ 4, 4 ])

painted.append([ 1, 5 ])

painted.append([ 2, 3 ])

painted.append([ 1, 1 ])

painted.append([ 1, 4 ])


CountSquares(H, W, N, K, P, painted)


# This code is contributed by Mohit Kumar





Output:


4





 Time Complexity :  O(N*p*p)



          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
ajourney
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.


Improved By :  mohit kumar 29


      
      
      
      

      

      
					
		

    Article Tags : 
Arrays
Matrix

           	
Practice Tags : 
Arrays
Hash
Matrix

        

         

         
 
                1

                

        



        
        
        
        
        

    

            

            3
            

            

             
                 Based on 1 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.