# Paths from entry to exit in matrix and maximum path sum

Given a maze which is a N * N grid grid[][]. Every cell of the maze contains either the number 1, 2 or 3 which defines the moves as:

• If grid[i][j] = 1 then the only valid move is grid[i][j + 1].
• If grid[i][j] = 2 then the only valid move is grid[i + 1][j].
• If grid[i][j] = 3 then the valid moves are grid[i][j + 1] and grid[i + 1][j].

Now, the task is to find the count of all the paths from grid to grid[N – 1][N – 1] and the maximum possible sum among all the paths i.e. when all the values at the visited cells are added to the sum.

Examples:

Input: grid[][] = {
{3, 2},
{3, 1}}
Output:
Total paths: 2
Maximum sum: 7
The two valid paths are
(0, 0) -> (0, 1) -> (1, 1) with sum as 3 + 2 + 1 = 6
and (0, 0) -> (1, 0) -> (1, 1) with sum as 3 + 3 + 1 = 7

Input: grid[][] = {
{1, 1, 3, 2, 1},
{3, 2, 2, 1, 2},
{1, 3, 3, 1, 3},
{1, 2, 3, 1, 2},
{1, 1, 1, 3, 1}}
Output:
Total paths: 4
Maximum sum: 18

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

Approach: This problem can be solved using dynamic programming.
To count the number of paths, create a dp[][] array where dp[i][j] will store the count of paths from grid[i][j] to grid[N – 1][N – 1] and the recurrence relation will be,

1. If grid[i][j] = 1 then dp[i][j] = dp[i][j + 1].
2. If grid[i][j] = 2 then dp[i][j] = dp[i + 1][j].
3. If grid[i][j] = 1 then dp[i][j] = dp[i][j + 1] + dp[i + 1][j].

and the termination condition will be when source and destination are same i.e. dp[N – 1][N – 1] = 1.

Now, to find the maximum sum path, another dp[][] array can be created where dp[i][j] will store the maximum sum of the path from grid[i][j] to grid[N – 1][N – 1] and the recurrence relation will be,

1. If grid[i][j] = 1 then dp[i][j] = grid[i][j] + dp[i][j + 1].
2. If grid[i][j] = 2 then dp[i][j] = grid[i][j] + dp[i + 1][j].
3. If grid[i][j] = 1 then dp[i][j] = grid[i][j] + max(dp[i][j + 1] + dp[i + 1][j]).

and the termination condition will again be when source and destination are same i.e. dp[N – 1][N – 1] = grid[N – 1][N – 1].

## C++

 `// C++ implementation of the approach ` `#include ` `#define COL 5 ` `#define ROW 5 ` `using` `namespace` `std; ` ` `  `// Recursive function to return the total ` `// paths from grid[i][j] to grid[n - 1][n - 1] ` `int` `totalPaths(``int` `i, ``int` `j, ``int` `n,  ` `                ``int` `grid[][COL], ``int` `dp[][COL]) ` `{ ` ` `  `    ``// Out of bounds ` `    ``if` `(i < 0 || j < 0 || i >= n || j >= n) ` `        ``return` `0; ` ` `  `    ``// If the current state hasn't been solved before ` `    ``if` `(dp[i][j] == -1)  ` `    ``{ ` ` `  `        ``// Only valid move is right ` `        ``if` `(grid[i][j] == 1) ` `            ``dp[i][j] = totalPaths(i, j + 1, n, grid, dp); ` ` `  `        ``// Only valid move is down ` `        ``else` `if` `(grid[i][j] == 2) ` `            ``dp[i][j] = totalPaths(i + 1, j, n, grid, dp); ` ` `  `        ``// Right and down, both are valid moves ` `        ``else` `            ``dp[i][j] = totalPaths(i, j + 1, n, grid, dp) ` `                    ``+ totalPaths(i + 1, j, n, grid, dp); ` `    ``} ` `    ``return` `dp[i][j]; ` `} ` ` `  ` `  `// Recursive function to return the maximum ` `// sum along the path from grid[i][j] to grid[n - 1][n - 1] ` `int` `maxSumPath(``int` `i, ``int` `j, ``int` `n,  ` `                ``int` `grid[ROW][COL], ``int` `dp[ROW][COL]) ` `{ ` ` `  `    ``// Out of bounds ` `    ``if` `(i < 0 || j < 0 || i >= n || j >= n) ` `        ``return` `0; ` ` `  `    ``// If the current state hasn't been solved before ` `    ``if` `(dp[i][j] == -1) ` `    ``{ ` ` `  `        ``// Only valid move is right ` `        ``if` `(grid[i][j] == 1) ` `            ``dp[i][j] = grid[i][j] + maxSumPath(i,  ` `                                    ``j + 1, n, grid, dp); ` ` `  `        ``// Only valid move is down ` `        ``else` `if` `(grid[i][j] == 2) ` `            ``dp[i][j] = grid[i][j] + maxSumPath(i + 1, ` `                                    ``j, n, grid, dp); ` ` `  `        ``// Right and down, both are valid moves ` `        ``else` `            ``dp[i][j] = grid[i][j] ` `                    ``+ max(maxSumPath(i, j + 1, n, grid, dp), ` `                        ``maxSumPath(i + 1, j, n, grid, dp)); ` `    ``} ` `    ``return` `dp[i][j]; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `grid[ROW][COL] = { { 1, 1, 3, 2, 1 }, ` `                           ``{ 3, 2, 2, 1, 2 }, ` `                           ``{ 1, 3, 3, 1, 3 }, ` `                           ``{ 1, 2, 3, 1, 2 }, ` `                           ``{ 1, 1, 1, 3, 1 } }; ` `    ``int` `n = ROW; ` ` `  `    ``// Fill the dp[][] array with -1 ` `    ``int` `dp[ROW][COL]; ` `     `  `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``for``(``int` `j = 0; j < n; j++) ` `        ``dp[i][j] = -1; ` `    ``} ` ` `  `    ``// When source and destination are same ` `    ``// then there is only 1 path ` `    ``dp[n - 1][n - 1] = 1; ` ` `  `    ``// Print the count of paths from ` `    ``// grid to grid[n - 1][n - 1] ` `    ``cout<<``"Total paths: "` `        ``<< totalPaths(0, 0, n, grid, dp) << endl; ` ` `  `    ``// Fill the dp[][] array again with -1 ` `    ``//for (int i = 0; i < n; i++) ` `    ``// Arrays.fill(dp[i], -1); ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``for``(``int` `j = 0; j < n; j++) ` `        ``dp[i][j] = -1; ` `    ``} ` ` `  `    ``// When source and destination are same ` `    ``// then the sum is grid[n - 1][n - 1] ` `    ``dp[n - 1][n - 1] = grid[n - 1][n - 1]; ` ` `  `    ``// Print the maximum sum among all the paths ` `    ``// from grid to grid[n - 1][n - 1] ` `    ``cout<< ``"Maximum sum: "` `        ``<< maxSumPath(0, 0, n, grid, dp)<

## Java

 `// Java implementation of the approach ` `import` `java.util.Arrays; ` ` `  `class` `GFG { ` ` `  `    ``// Recursive function to return the total ` `    ``// paths from grid[i][j] to grid[n - 1][n - 1] ` `    ``static` `int` `totalPaths(``int` `i, ``int` `j, ``int` `n, ``int` `grid[][], ``int` `dp[][]) ` `    ``{ ` ` `  `        ``// Out of bounds ` `        ``if` `(i < ``0` `|| j < ``0` `|| i >= n || j >= n) ` `            ``return` `0``; ` ` `  `        ``// If the current state hasn't been solved before ` `        ``if` `(dp[i][j] == -``1``) { ` ` `  `            ``// Only valid move is right ` `            ``if` `(grid[i][j] == ``1``) ` `                ``dp[i][j] = totalPaths(i, j + ``1``, n, grid, dp); ` ` `  `            ``// Only valid move is down ` `            ``else` `if` `(grid[i][j] == ``2``) ` `                ``dp[i][j] = totalPaths(i + ``1``, j, n, grid, dp); ` ` `  `            ``// Right and down, both are valid moves ` `            ``else` `                ``dp[i][j] = totalPaths(i, j + ``1``, n, grid, dp) ` `                           ``+ totalPaths(i + ``1``, j, n, grid, dp); ` `        ``} ` `        ``return` `dp[i][j]; ` `    ``} ` ` `  `    ``// Recursive function to return the maximum ` `    ``// sum along the path from grid[i][j] to grid[n - 1][n - 1] ` `    ``static` `int` `maxSumPath(``int` `i, ``int` `j, ``int` `n, ``int` `grid[][], ``int` `dp[][]) ` `    ``{ ` ` `  `        ``// Out of bounds ` `        ``if` `(i < ``0` `|| j < ``0` `|| i >= n || j >= n) ` `            ``return` `0``; ` ` `  `        ``// If the current state hasn't been solved before ` `        ``if` `(dp[i][j] == -``1``) { ` ` `  `            ``// Only valid move is right ` `            ``if` `(grid[i][j] == ``1``) ` `                ``dp[i][j] = grid[i][j] + maxSumPath(i, j + ``1``, n, grid, dp); ` ` `  `            ``// Only valid move is down ` `            ``else` `if` `(grid[i][j] == ``2``) ` `                ``dp[i][j] = grid[i][j] + maxSumPath(i + ``1``, j, n, grid, dp); ` ` `  `            ``// Right and down, both are valid moves ` `            ``else` `                ``dp[i][j] = grid[i][j] ` `                           ``+ Math.max(maxSumPath(i, j + ``1``, n, grid, dp), ` `                                      ``maxSumPath(i + ``1``, j, n, grid, dp)); ` `        ``} ` `        ``return` `dp[i][j]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `grid[][] = { { ``1``, ``1``, ``3``, ``2``, ``1` `}, ` `                         ``{ ``3``, ``2``, ``2``, ``1``, ``2` `}, ` `                         ``{ ``1``, ``3``, ``3``, ``1``, ``3` `}, ` `                         ``{ ``1``, ``2``, ``3``, ``1``, ``2` `}, ` `                         ``{ ``1``, ``1``, ``1``, ``3``, ``1` `} }; ` `        ``int` `n = grid.length; ` ` `  `        ``// Fill the dp[][] array with -1 ` `        ``int` `dp[][] = ``new` `int``[n][n]; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``Arrays.fill(dp[i], -``1``); ` ` `  `        ``// When source and destination are same ` `        ``// then there is only 1 path ` `        ``dp[n - ``1``][n - ``1``] = ``1``; ` ` `  `        ``// Print the count of paths from ` `        ``// grid to grid[n - 1][n - 1] ` `        ``System.out.println(``"Total paths: "` `                           ``+ totalPaths(``0``, ``0``, n, grid, dp)); ` ` `  `        ``// Fill the dp[][] array again with -1 ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``Arrays.fill(dp[i], -``1``); ` ` `  `        ``// When source and destination are same ` `        ``// then the sum is grid[n - 1][n - 1] ` `        ``dp[n - ``1``][n - ``1``] = grid[n - ``1``][n - ``1``]; ` ` `  `        ``// Print the maximum sum among all the paths ` `        ``// from grid to grid[n - 1][n - 1] ` `        ``System.out.println(``"Maximum sum: "` `                           ``+ maxSumPath(``0``, ``0``, n, grid, dp)); ` `    ``} ` `} `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Recursive function to return the total  ` `# paths from grid[i][j] to grid[n - 1][n - 1]  ` `def` `totalPaths(i, j, n, grid, dp):  ` ` `  `    ``# Out of bounds  ` `    ``if` `(i < ``0` `or` `j < ``0` `or` `i >``=` `n ``or` `j >``=` `n):  ` `        ``return` `0` ` `  `    ``# If the current state  ` `    ``# hasn't been solved before  ` `    ``if` `(dp[i][j] ``=``=` `-``1``):  ` `     `  `        ``# Only valid move is right  ` `        ``if` `(grid[i][j] ``=``=` `1``):  ` `            ``dp[i][j] ``=` `totalPaths(i, j ``+` `1``, n, grid, dp)  ` ` `  `        ``# Only valid move is down  ` `        ``elif` `(grid[i][j] ``=``=` `2``):  ` `            ``dp[i][j] ``=` `totalPaths(i ``+` `1``, j, n, grid, dp)  ` ` `  `        ``# Right and down, both are valid moves  ` `        ``else``: ` `            ``dp[i][j] ``=` `totalPaths(i, j ``+` `1``, n, grid, dp) ``+``\ ` `                       ``totalPaths(i ``+` `1``, j, n, grid, dp)  ` `     `  `    ``return` `dp[i][j]  ` ` `  `# Recursive function to return the maximum  ` `# sum along the path from grid[i,j] to grid[n - 1,n - 1]  ` `def` `maxSumPath(i, j, n, grid, dp):  ` ` `  `    ``# Out of bounds  ` `    ``if` `(i < ``0` `or` `j < ``0` `or` `i >``=` `n ``or` `j >``=` `n):  ` `        ``return` `0` ` `  `    ``# If the current state  ` `    ``# hasn't been solved before  ` `    ``if` `(dp[i][j] ``=``=` `-``1``):  ` `     `  `        ``# Only valid move is right  ` `        ``if` `(grid[i][j] ``=``=` `1``):  ` `            ``dp[i][j] ``=` `grid[i][j] ``+` `\ ` `                       ``maxSumPath(i, j ``+` `1``, n, grid, dp)  ` ` `  `        ``# Only valid move is down  ` `        ``elif` `(grid[i][j] ``=``=` `2``):  ` `            ``dp[i][j] ``=` `grid[i][j] ``+` `\ ` `                       ``maxSumPath(i ``+` `1``, j, n, grid, dp)  ` ` `  `        ``# Right and down, both are valid moves  ` `        ``else``: ` `            ``dp[i][j] ``=` `grid[i][j] ``+` `\ ` `                       ``max``(maxSumPath(i, j ``+` `1``, n, grid, dp),  ` `                           ``maxSumPath(i ``+` `1``, j, n, grid, dp))  ` `     `  `    ``return` `dp[i][j]  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``grid ``=` `[[ ``1``, ``1``, ``3``, ``2``, ``1` `],  ` `            ``[ ``3``, ``2``, ``2``, ``1``, ``2` `],  ` `            ``[ ``1``, ``3``, ``3``, ``1``, ``3` `],  ` `            ``[ ``1``, ``2``, ``3``, ``1``, ``2` `],  ` `            ``[ ``1``, ``1``, ``1``, ``3``, ``1` `]] ` ` `  `    ``n ``=` `len``(grid[``0``]) ` ` `  `    ``# Fill the dp[n][n] array with -1 ` `    ``dp``=` `[[``-``1``] ``*` `n] ``*` `n  ` ` `  `    ``# When source and destination are same  ` `    ``# then there is only 1 path  ` `    ``dp[n ``-` `1``][n ``-` `1``] ``=` `1` ` `  `    ``# Print the count of paths from  ` `    ``# grid[0,0] to grid[n - 1][n - 1]  ` `    ``print``(``"Total paths:"``,  ` `           ``totalPaths(``0``, ``0``, n, grid, dp))  ` ` `  `    ``# Fill the dp[n][n] array again with -1  ` `    ``dp``=` `[[``-``1``] ``*` `n] ``*` `n  ` ` `  `    ``# When source and destination are same  ` `    ``# then the sum is grid[n - 1][n - 1]  ` `    ``dp[n ``-` `1``][n ``-` `1``] ``=` `grid[n ``-` `1``][n ``-` `1``]  ` ` `  `    ``# Print the maximum sum among all the paths  ` `    ``# from grid[0,0] to grid[n - 1][n - 1]  ` `    ``print``(``"Maximum sum:"``,  ` `           ``maxSumPath(``0``, ``0``, n, grid, dp))  ` ` `  `# This code is contributed by ashutosh450  `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `// Recursive function to return the total ` `// paths from grid[i][j] to grid[n - 1][n - 1] ` `static` `int` `totalPaths(``int` `i, ``int` `j, ``int` `n,  ` `                      ``int` `[,]grid, ``int` `[,]dp) ` `{ ` ` `  `    ``// Out of bounds ` `    ``if` `(i < 0 || j < 0 || i >= n || j >= n) ` `        ``return` `0; ` ` `  `    ``// If the current state ` `    ``// hasn't been solved before ` `    ``if` `(dp[i, j] == -1) ` `    ``{ ` ` `  `        ``// Only valid move is right ` `        ``if` `(grid[i, j] == 1) ` `            ``dp[i, j] = totalPaths(i, j + 1, n, grid, dp); ` ` `  `        ``// Only valid move is down ` `        ``else` `if` `(grid[i, j] == 2) ` `            ``dp[i, j] = totalPaths(i + 1, j, n, grid, dp); ` ` `  `        ``// Right and down, both are valid moves ` `        ``else` `            ``dp[i, j] = totalPaths(i, j + 1, n, grid, dp) +  ` `                      ``totalPaths(i + 1, j, n, grid, dp); ` `    ``} ` `    ``return` `dp[i, j]; ` `} ` ` `  `// Recursive function to return the maximum ` `// sum along the path from grid[i,j] to grid[n - 1,n - 1] ` `static` `int` `maxSumPath(``int` `i, ``int` `j, ``int` `n, ` `                      ``int` `[,]grid, ``int` `[,]dp) ` `{ ` ` `  `    ``// Out of bounds ` `    ``if` `(i < 0 || j < 0 || i >= n || j >= n) ` `        ``return` `0; ` ` `  `    ``// If the current state  ` `    ``// hasn't been solved before ` `    ``if` `(dp[i, j] == -1)  ` `    ``{ ` ` `  `        ``// Only valid move is right ` `        ``if` `(grid[i, j] == 1) ` `            ``dp[i, j] = grid[i, j] + maxSumPath(i, j + 1,  ` `                                               ``n, grid, dp); ` ` `  `        ``// Only valid move is down ` `        ``else` `if` `(grid[i,j] == 2) ` `            ``dp[i, j] = grid[i, j] + maxSumPath(i + 1, j, ` `                                               ``n, grid, dp); ` ` `  `        ``// Right and down, both are valid moves ` `        ``else` `            ``dp[i, j] = grid[i, j] +  ` `                       ``Math.Max(maxSumPath(i, j + 1, n, grid, dp),  ` `                                ``maxSumPath(i + 1, j, n, grid, dp)); ` `    ``} ` `    ``return` `dp[i, j]; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[,]grid = { { 1, 1, 3, 2, 1 }, ` `                    ``{ 3, 2, 2, 1, 2 }, ` `                    ``{ 1, 3, 3, 1, 3 }, ` `                    ``{ 1, 2, 3, 1, 2 }, ` `                    ``{ 1, 1, 1, 3, 1 } }; ` `    ``int` `n = grid.GetLength(0); ` ` `  `    ``// Fill the dp[,] array with -1 ` `    ``int` `[,]dp = ``new` `int``[n, n]; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``dp[i, j] = -1; ` ` `  `    ``// When source and destination are same ` `    ``// then there is only 1 path ` `    ``dp[n - 1, n - 1] = 1; ` ` `  `    ``// Print the count of paths from ` `    ``// grid[0,0] to grid[n - 1,n - 1] ` `    ``Console.WriteLine(``"Total paths: "` `+  ` `                       ``totalPaths(0, 0, n, grid, dp)); ` ` `  `    ``// Fill the dp[,] array again with -1 ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``dp[i, j] = -1; ` ` `  `    ``// When source and destination are same ` `    ``// then the sum is grid[n - 1,n - 1] ` `    ``dp[n - 1, n - 1] = grid[n - 1, n - 1]; ` ` `  `    ``// Print the maximum sum among all the paths ` `    ``// from grid[0,0] to grid[n - 1,n - 1] ` `    ``Console.WriteLine(``"Maximum sum: "` `+  ` `                       ``maxSumPath(0, 0, n, grid, dp)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```Total paths: 4
Maximum sum: 18
```

Time complexity: O(n2)
Space complexity: O(n2)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.