Given an **N * N** board which is initially empty and a sequence of queries, each query consists of two integers **X** and **Y** where the cell **(X, Y)** is painted. The task is to print the number of the query after which there will be a **3 * 3** square in the board with all the cells painted.

If there is no such square after processing all of the queries then print **-1**.

**Examples:**

Input:N = 4, q = {{1, 1}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 4}, {2, 4}, {3, 4}, {3, 2}, {3, 3}, {4, 1}}

Output:10

After the 10th move, there exists a 3X3 square, from (1, 1) to (3, 3) (1-based indexing).

Input:N = 3, q = {(1, 1), {1, 2}, {1, 3}}

Output:-1

**Approach:** An important observation here is that every time we colour a square, it can be a part of the required square in 9 different ways (any cell of the 3 * 3 square) . For every possibility, check whether the current cell is a part of any square where all the 9 cells are painted. If the condition is satisfied print the number of queries processed so far else print **-1** after all the queries have been processed.

Below is the implementation of the above approach:

`// C++ implementation of the approach ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function that returns true ` `// if the coordinate is inside the grid ` `bool` `valid(` `int` `x, ` `int` `y, ` `int` `n) ` `{ ` ` ` `if` `(x < 1 || y < 1 || x > n || y > n) ` ` ` `return` `false` `; ` ` ` `return` `true` `; ` `} ` ` ` `// Function that returns the count of squares ` `// that are coloured in the 3X3 square ` `// with (cx, cy) being the top left corner ` `int` `count(` `int` `n, ` `int` `cx, ` `int` `cy, ` ` ` `vector<vector<` `bool` `> >& board) ` `{ ` ` ` `int` `ct = 0; ` ` ` ` ` `// Iterate through 3 rows ` ` ` `for` `(` `int` `x = cx; x <= cx + 2; x++) ` ` ` ` ` `// Iterate through 3 columns ` ` ` `for` `(` `int` `y = cy; y <= cy + 2; y++) ` ` ` ` ` `// Check if the current square ` ` ` `// is valid and coloured ` ` ` `if` `(valid(x, y, n)) ` ` ` `ct += board[x][y]; ` ` ` `return` `ct; ` `} ` ` ` `// Function that returns the query ` `// number after which the grid will ` `// have a 3X3 coloured square ` `int` `minimumMoveSquare(` `int` `n, ` `int` `m, ` ` ` `vector<pair<` `int` `, ` `int` `> > moves) ` `{ ` ` ` `int` `x, y; ` ` ` `vector<vector<` `bool` `> > board(n + 1); ` ` ` ` ` `// Initialize all squares to be uncoloured ` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `board[i].resize(n + 1, ` `false` `); ` ` ` `for` `(` `int` `i = 0; i < moves.size(); i++) { ` ` ` `x = moves[i].first; ` ` ` `y = moves[i].second; ` ` ` ` ` `// Mark the current square as coloured ` ` ` `board[x][y] = ` `true` `; ` ` ` ` ` `// Check if any of the 3X3 squares ` ` ` `// which contains the current square ` ` ` `// is fully coloured ` ` ` `for` `(` `int` `cx = x - 2; cx <= x; cx++) ` ` ` `for` `(` `int` `cy = y - 2; cy <= y; cy++) ` ` ` `if` `(count(n, cx, cy, board) == 9) ` ` ` `return` `i + 1; ` ` ` `} ` ` ` ` ` `return` `-1; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `n = 3; ` ` ` `vector<pair<` `int` `, ` `int` `> > moves = { { 1, 1 }, ` ` ` `{ 1, 2 }, ` ` ` `{ 1, 3 } }; ` ` ` `int` `m = moves.size(); ` ` ` ` ` `cout << minimumMoveSquare(n, m, moves); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

-1

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.