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
Approach:
- Initialize a 2D array dp of size m x n with all values as INT_MAX.
- Set dp[0][0] to 1, as the first cell is already reached.
- Iterate through each cell of the matrix, and check if the current cell can be reached from any cell already reached, i.e., if dp[i][j] != INT_MAX. If it can be reached, update the minimum cells required to reach the current cell from the previous cell by checking the cells to the right and bottom of the current cell.
- Return dp[m-1][n-1] if it is not equal to INT_MAX, else return -1.
Algorithm: A dynamic programming approach is given below:
Below is the implementation of above approach:
// 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;
} |
// Java implementation to count minimum // cells required to be covered to reach // destination import java.util.*;
import java.io.*;
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 */ |
Minimum number of cells = 4
Time Complexity: O(m*n)
Auxiliary Space: O(m*n)