Minimum cells required to reach destination with jumps equal to cell values

Last Updated : 21 Mar, 2023

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:

1. Initialize a 2D array dp of size m x n with all values as INT_MAX.
2. Set dp[0][0] to 1, as the first cell is already reached.
3. 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.
4. 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++

 `// C++ implementation to count minimum cells required` `// to be covered to reach destination` `#include `   `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

 `// 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 */`

Javascript

Output

`Minimum number of cells = 4`

Time Complexity: O(m*n)
Auxiliary Space: O(m*n)