Minimum cells required to reach destination with jumps equal to cell values
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++
#include <bits/stdc++.h>
using namespace std;
#define SIZE 100
int minCells( int mat[SIZE][SIZE], int m, int n)
{
int dp[m][n];
for ( int i = 0; i < m; i++)
for ( int j = 0; j < n; j++)
dp[i][j] = INT_MAX;
dp[0][0] = 1;
for ( int i = 0; i < m; i++) {
for ( int j = 0; j < n; 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;
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;
}
}
if (dp[m - 1][n - 1] != INT_MAX)
return dp[m - 1][n - 1];
return -1;
}
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
import java.util.*;
import java.io.*;
class MinCellsDestination
{
static final int SIZE= 100 ;
static int minCells( int mat[][], int m, int n)
{
int dp[][] = new int [m][n];
for ( int i = 0 ; i < m; i++)
for ( int j = 0 ; j < n; j++)
dp[i][j] = Integer.MAX_VALUE;
dp[ 0 ][ 0 ] = 1 ;
for ( int i = 0 ; i < m; i++) {
for ( int j = 0 ; j < n; 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 ;
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 ;
}
}
if (dp[m - 1 ][n - 1 ] != Integer.MAX_VALUE)
return dp[m - 1 ][n - 1 ];
return - 1 ;
}
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));
}
}
|
Python3
C#
PHP
Javascript
Output
Minimum number of cells = 4
Time Complexity: O(m*n)
Auxiliary Space: O(m*n)
Last Updated :
21 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...