# 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 = 4, then one can move to cells mat and mat 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

## 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 ``=` `3` `n ``=` `5`  `print``(``"Minimum number of cells = "``, ` `     ``minCells(mat, m, n)) ` `#this code is contributed by sahilshelangia `

## 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. `

## PHP

 ` `

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.