Given a grid A of size N*M consisting of K cells denoted by values in range [1, K], some blocked cells denoted by -1 and remaining unblocked cells denoted by 0, the task is to check if it is possible to connect those K cells, directly or indirectly, by unblocking atmost one cell. It is possible to move only to the adjacent horizontal and adjacent vertical cells.
Examples
Input:
A = {{0, 5, 6, 0},
{3, -1, -1, 4},
{-1, 2, 1, -1},
{-1, -1, -1, -1}},
K = 6
Output: Yes
Explanation:
Unblocking cell (2, 2) or (2, 3) or (3, 1) or
(3, 4) would make all the K cells connected.
Input:
A = {{-1, -1, 3, -1},
{1, 0, -1, -1},
{-1, -1, -1, 0},
{-1, 0, 2, -1}},
K = 3
Output: No
Explanation:
Atleast two cells need to be unblocked.
Approach: Perform BFS from the cells numbered 1 to K and mark every cell by the component to which it belongs. Check if there is any blocked cell having adjacent cells belonging to different components. If there exists any, then it is possible to connect by unblocking that cell. Otherwise, it is not possible.
Example:
After performing BFS and labeling the cells by their no of components, the array appears as follows:
A={{1, 1, 1, 1}, {1, -1, -1, 1}, {-1, 2, 2, -1}, {-1, -1, -1, -1}}
The number of different label around the cell (2, 2) is 2.
Hence, unblocking it will connect the K cells.
Below is the implementation of the above approach:
C++
// C++ implementation of the above approach #include <bits/stdc++.h> using namespace std; #define pairs pair<int, int> void check(int k, vector<vector<int> > a, int n, int m) { int cells[k][2]; bool visited[n][m]; int count = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i][j] != 0 && a[i][j] != -1) { cells[count][0] = i; cells[count][1] = j; count++; } visited[i][j] = false; } } // Arrays to make grid traversals easier int dx[] = { 0, 0, 1, -1 }; int dy[] = { 1, -1, 0, 0 }; // Store number of components int component = 0; // Perform BFS and maark every cell // by the component in which it belongs for (int i = 0; i < k; i++) { int x = cells[i][0], y = cells[i][1]; if (visited[x][y]) continue; component++; queue<pairs> cells; cells.push(make_pair(x, y)); visited[x][y] = true; while (!cells.empty()) { pairs z = cells.front(); cells.pop(); a[z.first][z.second] = component; for (int j = 0; j < 4; j++) { int new_x = z.first + dx[j]; int new_y = z.second + dy[j]; if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= m) continue; if (visited[new_x][new_y] || a[new_x][new_y] == -1) continue; cells.push(make_pair(new_x, new_y)); visited[new_x][new_y] = true; } } } int maximum = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i][j] == -1) { unordered_set<int> set; for (int kk = 0; kk < 4; kk++) { int xx = i + dx[kk]; int yy = j + dy[kk]; if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue; // if the cell doesn't // belong to any component if (a[xx][yy] <= 0) continue; set.insert(a[xx][yy]); } int s = set.size(); maximum = max(s, maximum); } } } if (maximum == component) { cout << "Yes\n"; } else { cout << "No\n"; } } int main() { int k = 6; int n = 4, m = 4; vector<vector<int> > a = { { 0, 5, 6, 0 }, { 3, -1, -1, 4 }, { -1, 2, 1, -1 }, { -1, -1, -1, -1 } }; check(k, a, n, m); return 0; } |
chevron_right
filter_none
Java
// Java implementation of the above approach import java.util.*; class GFG{ static class pair { int first, second; public pair(int first, int second) { this.first = first; this.second = second; } } static void check(int k, int [][]a, int n, int m) { int [][]cell = new int[k][2]; boolean [][]visited = new boolean[n][m]; int count = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i][j] != 0 && a[i][j] != -1) { cell[count][0] = i; cell[count][1] = j; count++; } visited[i][j] = false; } } // Arrays to make grid traversals easier int dx[] = { 0, 0, 1, -1 }; int dy[] = { 1, -1, 0, 0 }; // Store number of components int component = 0; // Perform BFS and maark every cell // by the component in which it belongs for (int i = 0; i < k; i++) { int x = cell[i][0], y = cell[i][1]; if (visited[x][y]) continue; component++; Queue<pair> cells = new LinkedList<>(); cells.add(new pair(x, y)); visited[x][y] = true; while (!cells.isEmpty()) { pair z = cells.peek(); cells.remove(); a[z.first][z.second] = component; for (int j = 0; j < 4; j++) { int new_x = z.first + dx[j]; int new_y = z.second + dy[j]; if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= m) continue; if (visited[new_x][new_y] || a[new_x][new_y] == -1) continue; cells.add(new pair(new_x, new_y)); visited[new_x][new_y] = true; } } } int maximum = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i][j] == -1) { HashSet<Integer> set = new HashSet<Integer>(); for (int kk = 0; kk < 4; kk++) { int xx = i + dx[kk]; int yy = j + dy[kk]; if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue; // if the cell doesn't // belong to any component if (a[xx][yy] <= 0) continue; set.add(a[xx][yy]); } int s = set.size(); maximum = Math.max(s, maximum); } } } if (maximum == component) { System.out.print("Yes\n"); } else { System.out.print("No\n"); } } public static void main(String[] args) { int k = 6; int n = 4, m = 4; int [][]a = { { 0, 5, 6, 0 }, { 3, -1, -1, 4 }, { -1, 2, 1, -1 }, { -1, -1, -1, -1 } }; check(k, a, n, m); } } // This code is contributed by 29AjayKumar |
chevron_right
filter_none
Python3
# Python3 implementation of the above approach from collections import deque as queue def check(k, a, n, m): cells = [[0 for i in range(2)] for i in range(k)] visited = [[0 for i in range(m)] for i in range(n)] count = 0 for i in range(n): for j in range(m): if (a[i][j] != 0 and a[i][j] != -1): cells[count][0] = i cells[count][1] = j count += 1 visited[i][j] = False # Arrays to make grid traversals easier dx = [0, 0, 1, -1] dy = [1, -1, 0, 0] # Store number of components component = 0 # Perform BFS and maark every cell # by the component in which it belongs for i in range(k): x = cells[i][0] y = cells[i][1] if (visited[x][y]): continue component += 1 cell = queue() cell.append([x, y]) visited[x][y] = True while (len(cell) > 0): z = cell.popleft() a[z[0]][z[1]] = component for j in range(4): new_x = z[0] + dx[j] new_y = z[1] + dy[j] if (new_x < 0 or new_x >= n or new_y < 0 or new_y >= m): continue if (visited[new_x][new_y] or a[new_x][new_y] == -1): continue cell.append([new_x, new_y]) visited[new_x][new_y] = True maximum = 0 for i in range(n): for j in range(m): if (a[i][j] == -1): se = dict() for kk in range(4): xx = i + dx[kk] yy = j + dy[kk] if (xx < 0 or xx >= n or yy < 0 or yy >= m): continue # if the cell doesn't # belong to any component if (a[xx][yy] <= 0): continue se[a[xx][yy]] = 1 s = len(se) maximum = max(s, maximum) if (maximum == component): print("Yes\n") else: print("No\n") # Driver code if __name__ == '__main__': k = 6 n = 4 m = 4 a=[[0, 5, 6, 0 ], [3, -1, -1, 4], [-1, 2, 1, -1], [-1, -1,-1,-1]] check(k, a, n, m) # This code is contributed by mohit kumar 29 |
chevron_right
filter_none
C#
// C# implementation of the above approach using System; using System.Collections.Generic; class GFG{ class pair { public int first, second; public pair(int first, int second) { this.first = first; this.second = second; } } static void check(int k, int [,]a, int n, int m) { int [,]cell = new int[k,2]; bool [,]visited = new bool[n,m]; int count = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i, j] != 0 && a[i, j] != -1) { cell[count, 0] = i; cell[count, 1] = j; count++; } visited[i, j] = false; } } // Arrays to make grid traversals easier int []dx = { 0, 0, 1, -1 }; int []dy = { 1, -1, 0, 0 }; // Store number of components int component = 0; // Perform BFS and maark every cell // by the component in which it belongs for (int i = 0; i < k; i++) { int x = cell[i, 0], y = cell[i, 1]; if (visited[x, y]) continue; component++; List<pair> cells = new List<pair>(); cells.Add(new pair(x, y)); visited[x, y] = true; while (cells.Count != 0) { pair z = cells[0]; cells.RemoveAt(0); a[z.first,z.second] = component; for (int j = 0; j < 4; j++) { int new_x = z.first + dx[j]; int new_y = z.second + dy[j]; if (new_x < 0 || new_x >= n || new_y < 0 || new_y >= m) continue; if (visited[new_x,new_y] || a[new_x, new_y] == -1) continue; cells.Add(new pair(new_x, new_y)); visited[new_x, new_y] = true; } } } int maximum = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i, j] == -1) { HashSet<int> set = new HashSet<int>(); for (int kk = 0; kk < 4; kk++) { int xx = i + dx[kk]; int yy = j + dy[kk]; if (xx < 0 || xx >= n || yy < 0 || yy >= m) continue; // if the cell doesn't // belong to any component if (a[xx, yy] <= 0) continue; set.Add(a[xx, yy]); } int s = set.Count; maximum = Math.Max(s, maximum); } } } if (maximum == component) { Console.Write("Yes\n"); } else { Console.Write("No\n"); } } public static void Main(String[] args) { int k = 6; int n = 4, m = 4; int [,]a = { { 0, 5, 6, 0 }, { 3, -1, -1, 4 }, { -1, 2, 1, -1 }, { -1, -1, -1, -1 } }; check(k, a, n, m); } } // This code is contributed by 29AjayKumar |
chevron_right
filter_none
Output:
Yes
Performance Analysis:
- Time Complexity: Performing BFS on the matrix takes O(N*M) time and O(N*M) time for checking every blocked cell. Hence the overall Time Complexity will be O(N * M).
- Auxiliary Space Complexity: O(N * M)
Recommended Posts:
- Longest subarray of non-empty cells after removal of at most a single empty cell
- Color a grid such that all same color cells are connected either horizontally or vertically
- Minimum Numbers of cells that are connected with the smallest path between 3 given cells
- Number of shortest paths to reach every cell from bottom-left cell in the grid
- Size of all connected non-empty cells of a Matrix
- Minimum cells traversed to reach corner where every cell represents jumps
- Minimum cells required to reach destination with jumps equal to cell values
- Shortest distance between two cells in a matrix or grid
- Min number of moves to traverse entire Matrix through connected cells with equal values
- Largest connected component on a grid
- Length of longest connected 1’s in a Binary Grid
- Number of ways to paint K cells in 3 x N grid such that no P continuous columns are left unpainted
- Minimum number of Water to Land conversion to make two islands connected in a Grid
- Count of cells in a matrix whose adjacent cells's sum is prime Number
- Check if a cell can be visited more than once in a String
- Minimum moves taken to move coin of each cell to any one cell of Matrix
- Maximum of all distances to the nearest 1 cell from any 0 cell in a Binary matrix
- Check if a Queen can attack a given cell on chessboard
- Check if a directed graph is connected or not
- Maximum path sum that starting with any cell of 0-th row and ending with any cell of (N-1)-th row
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.
