Given a m x n matrix mat[][] containing positive integers. The problem is to reach to the cell (m-1, n-1) from the cell (0, 0) by following the given constraints. From a cell (i, j) one can move ‘exactly’ a distance of ‘mat[i][j]’ to the right (in the same row) or to below (in the same column) only if the movement takes to a cell within matrix boundaries.
For example: Given mat[1][1] = 4, then one can move to cells mat[1][5] and mat[5][1] only if these cells exists in the matrix. Following the constraints check whether one can reach cell (m-1, n-1) from (0, 0). 1If one can reach then print the minimum number of cells required to be covered during the movement else print “-1”.
Examples:
Input : mat[][] = { {2, 3, 2, 1, 4},
{3, 2, 5, 8, 2},
{1, 1, 2, 2, 1} }
Output : 4
The movement and cells covered are as follows:
(0, 0)->(0, 2)
|
(2, 2)->(2, 4)
Input : mat[][] = { {2, 4, 2},
{5, 3, 8},
{1, 1, 1} }
Output : 3
Algorithm: A dynamic programming approach is given below:
Below is the implementation of above approach:
C++
// C++ implementation to count minimum cells required // to be covered to reach destination #include <bits/stdc++.h> using namespace std; #define SIZE 100 // function to count minimum cells required // to be covered to reach destination int minCells(int mat[SIZE][SIZE], int m, int n) { // to store min cells required to be // covered to reach a particular cell int dp[m][n]; // initially no cells can be reached for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) dp[i][j] = INT_MAX; // base case dp[0][0] = 1; // building up the dp[][] matrix for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { // dp[i][j] != INT_MAX denotes that cell (i, j) // can be reached from cell (0, 0) and the other // half of the condition finds the cell on the // right that can be reached from (i, j) if (dp[i][j] != INT_MAX && (j + mat[i][j]) < n && (dp[i][j] + 1) < dp[i][j + mat[i][j]]) dp[i][j + mat[i][j]] = dp[i][j] + 1; // the other half of the condition finds the cell // right below that can be reached from (i, j) if (dp[i][j] != INT_MAX && (i + mat[i][j]) < m && (dp[i][j] + 1) < dp[i + mat[i][j]][j]) dp[i + mat[i][j]][j] = dp[i][j] + 1; } } // it true then cell (m-1, n-1) can be reached // from cell (0, 0) and returns the minimum // number of cells covered if (dp[m - 1][n - 1] != INT_MAX) return dp[m - 1][n - 1]; // cell (m-1, n-1) cannot be reached from // cell (0, 0) return -1; } // Driver program to test above int main() { int mat[SIZE][SIZE] = { { 2, 3, 2, 1, 4 }, { 3, 2, 5, 8, 2 }, { 1, 1, 2, 2, 1 } }; int m = 3, n = 5; cout << "Minimum number of cells = " << minCells(mat, m, n); return 0; } |
chevron_right
filter_none
Java
// Java implementation to count minimum // cells required to be covered to reach // destination class MinCellsDestination { static final int SIZE=100; // function to count minimum cells required // to be covered to reach destination static int minCells(int mat[][], int m, int n) { // to store min cells required to be // covered to reach a particular cell int dp[][] = new int[m][n]; // initially no cells can be reached for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) dp[i][j] = Integer.MAX_VALUE; // base case dp[0][0] = 1; // building up the dp[][] matrix for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { // dp[i][j] != INT_MAX denotes that cell // (i, j) can be reached from cell (0, 0) // and the other half of the condition // finds the cell on the right that can // be reached from (i, j) if (dp[i][j] != Integer.MAX_VALUE && (j + mat[i][j]) < n && (dp[i][j] + 1) < dp[i][j + mat[i][j]]) dp[i][j + mat[i][j]] = dp[i][j] + 1; // the other half of the condition finds // the cell right below that can be // reached from (i, j) if (dp[i][j] != Integer.MAX_VALUE && (i + mat[i][j]) < m && (dp[i][j] + 1) < dp[i + mat[i][j]][j]) dp[i + mat[i][j]][j] = dp[i][j] + 1; } } // it true then cell (m-1, n-1) can be reached // from cell (0, 0) and returns the minimum // number of cells covered if (dp[m - 1][n - 1] != Integer.MAX_VALUE) return dp[m - 1][n - 1]; // cell (m-1, n-1) cannot be reached from // cell (0, 0) return -1; } // Driver code public static void main(String args[]) { int mat[][] = { { 2, 3, 2, 1, 4 }, { 3, 2, 5, 8, 2 }, { 1, 1, 2, 2, 1 }}; int m = 3, n = 5; System.out.println("Minimum number of cells" + " = " + minCells(mat, m, n)); } } /* This code is contributed by Danish Kaleem */ |
chevron_right
filter_none
Python3
# Python3 implementation to count minimum cells required # to be covered to reach destination SIZE=100 MAX=10000000# function to count minimum cells required # to be covered to reach destination def minCells( mat, m, n): # to store min cells required to be # covered to reach a particular cell dp=[[MAX for i in range(n)]for i in range(m)] # initially no cells can be reached # base case dp[0][0] = 1 # building up the dp[][] matrix for i in range(m): for j in range(n): # dp[i][j] != MAX denotes that cell (i, j) # can be reached from cell (0, 0) and the other # half of the condition finds the cell on the # right that can be reached from (i, j) if (dp[i][j] != MAX and (j + mat[i][j]) < n and (dp[i][j] + 1) < dp[i][j + mat[i][j]]): dp[i][j + mat[i][j]] = dp[i][j] + 1 # the other half of the condition finds the cell # right below that can be reached from (i, j) if (dp[i][j] != MAX and (i + mat[i][j]) < m and (dp[i][j] + 1) < dp[i + mat[i][j]][j]): dp[i + mat[i][j]][j] = dp[i][j] + 1 # it true then cell (m-1, n-1) can be reached # from cell (0, 0) and returns the minimum # number of cells covered if (dp[m - 1][n - 1] != MAX): return dp[m - 1][n - 1] # cell (m-1, n-1) cannot be reached from # cell (0, 0) return -1 # Driver program to test above mat= [ [ 2, 3, 2, 1, 4 ], [ 3, 2, 5, 8, 2 ], [ 1, 1, 2, 2, 1 ]] m = 3n = 5 print("Minimum number of cells = ", minCells(mat, m, n)) #this code is contributed by sahilshelangia |
chevron_right
filter_none
C#
// C# implementation to count minimum // cells required to be covered to reach // destination using System; class GFG { //static int SIZE=100; // function to count minimum cells required // to be covered to reach destination static int minCells(int [,]mat, int m, int n) { // to store min cells required to be // covered to reach a particular cell int [,]dp = new int[m,n]; // initially no cells can be reached for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) dp[i,j] = int.MaxValue; // base case dp[0,0] = 1; // building up the dp[][] matrix for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { // dp[i][j] != INT_MAX denotes that // cell (i, j) can be reached from // cell (0, 0) and the other half // of the condition finds the cell // on the right that can be reached // from (i, j) if (dp[i,j] != int.MaxValue && (j + mat[i,j]) < n && (dp[i,j] + 1) < dp[i,j + mat[i,j]]) dp[i,j + mat[i,j]] = dp[i,j] + 1; // the other half of the condition // finds the cell right below that // can be reached from (i, j) if (dp[i,j] != int.MaxValue && (i + mat[i,j]) < m && (dp[i,j] + 1) < dp[i + mat[i,j],j]) dp[i + mat[i,j],j] = dp[i,j] + 1; } } // it true then cell (m-1, n-1) can be // reached from cell (0, 0) and returns // the minimum number of cells covered if (dp[m - 1,n - 1] != int.MaxValue) return dp[m - 1,n - 1]; // cell (m-1, n-1) cannot be reached from // cell (0, 0) return -1; } // Driver code public static void Main() { int [,]mat = { { 2, 3, 2, 1, 4 }, { 3, 2, 5, 8, 2 }, { 1, 1, 2, 2, 1 } }; int m = 3, n = 5; Console.WriteLine("Minimum number of " + "cells = " + minCells(mat, m, n)); } } // This code is contributed by anuj_67. |
chevron_right
filter_none
PHP
<?php // PHP implementation to count // minimum cells required to be // covered to reach destination // function to count minimum // cells required to be // covered to reach destination function minCells( $mat, $m, $n) { // to store min cells // required to be // covered to reach // a particular cell $dp =array(array()); // initially no cells // can be reached for($i = 0; $i < $m; $i++) for($j = 0; $j < $n; $j++) $dp[$i][$j] = PHP_INT_MAX; // base case $dp[0][0] = 1; // building up the dp[][] matrix for($i = 0; $i < $m; $i++) { for($j = 0; $j < $n; $j++) { // dp[i][j] != INT_MAX // denotes that cell (i, j) // can be reached from cell // (0, 0) and the other half // of the condition finds the // cell on the right that can // be reached from (i, j) if ($dp[$i][$j] != PHP_INT_MAX and ($j + $mat[$i][$j]) <$n and ($dp[$i][$j] + 1) < $dp[$i][$j + $mat[$i][$j]]) $dp[$i][$j + $mat[$i][$j]] = $dp[$i][$j] + 1; // the other half of the // condition finds the cell // right below that can be // reached from (i, j) if ($dp[$i][$j] != PHP_INT_MAX and ($i + $mat[$i][$j]) < $m and ($dp[$i][$j] + 1) < $dp[$i +$mat[$i][$j]][$j]) $dp[$i + $mat[$i][$j]][$j] = $dp[$i][$j] + 1; } } // it true then cell // (m-1, n-1) can be reached // from cell (0, 0) and // returns the minimum // number of cells covered if ($dp[$m - 1][$n - 1] != PHP_INT_MAX) return $dp[$m - 1][$n - 1]; // cell (m-1, n-1) cannot // be reached from // cell (0, 0) return -1; } // Driver Code $mat = array(array(2, 3, 2, 1, 4), array(3, 2, 5, 8, 2), array(1, 1, 2, 2, 1)); $m = 3; $n = 5; echo "Minimum number of cells = " , minCells($mat, $m, $n); // This code is contributed by anuj_67. ?> |
chevron_right
filter_none
Output:
Minimum number of cells = 4
Time Complexity: O(m*n)
Auxiliary Space: O(m*n)
This article is contributed by Ayush Jauhari. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
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.
Recommended Posts:
- Minimum cells traversed to reach corner where every cell represents jumps
- Number of shortest paths to reach every cell from bottom-left cell in the grid
- Check if a path exists for a cell valued 1 to reach the bottom right corner of a Matrix before any cell valued 2
- Count minimum factor jumps required to reach the end of an Array
- Minimum Numbers of cells that are connected with the smallest path between 3 given cells
- Minimum Distance from a given Cell to all other Cells of a Matrix
- Minimum moves taken to move coin of each cell to any one cell of Matrix
- Source to destination in 2-D path with fixed sized jumps
- Count of cells in a matrix which give a Fibonacci number when the count of adjacent cells is added
- Count of cells in a matrix whose adjacent cells's sum is prime Number
- Minimum number of jumps to reach end
- Minimum number of jumps to reach end | Set 2 (O(n) solution)
- Minimum jumps to reach last building in a matrix
- Minimum number of Fibonacci jumps to reach end
- Find the minimum cost to reach destination using a train
- Minimum steps to reach a destination
- Minimum Initial Points to Reach Destination
- Check if cells numbered 1 to K in a grid can be connected after removal of atmost one blocked cell
- Maximum path sum that starting with any cell of 0-th row and ending with any cell of (N-1)-th row
- Maximum of all distances to the nearest 1 cell from any 0 cell in a Binary matrix
