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

• Difficulty Level : Medium
• Last Updated : 24 Jan, 2022

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

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`

## Javascript

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

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

My Personal Notes arrow_drop_up