# Maximum sum path in a matrix from top to bottom

Consider a n*n matrix. Suppose each cell in the matrix has a value assigned. We can go from each cell in row i to a diagonally higher cell in row i+1 only [i.e from cell(i, j) to cell(i+1, j-1) and cell(i+1, j+1) only]. Find the path from the top row to the bottom row following the aforementioned condition such that the maximum sum is obtained.

Examples:

```Input : mat[][] = { {5, 6, 1, 7},
{-2, 10, 8, -1},
{3, -7, -9, 11},
{12, -4, 2, 6} }
Output : 28

{5, 6, 1, 7},
{-2, 10, 8, -1},
{3, -7, -9, 11},
{12, -4, 2, 6} }

The highlighted numbers from top to bottom
gives the required maximum sum path.
(7 + 8 + 11 + 2) = 28
```

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

Algorithm: The idea is to find maximum sum or all paths starting with every cell of first row and finally return maximum of all values in first row. We use Dynamic Programming as results of many subproblems are needed again and again.

## C++

 `// C++ implementation to find the maximum sum ` `// path in a matrix ` `#include ` `using` `namespace` `std; ` ` `  `#define SIZE 10 ` ` `  `// function to find the maximum sum ` `// path in a matric ` `int` `maxSum(``int` `mat[SIZE][SIZE], ``int` `n) ` `{ ` `    ``// if there is a single element only ` `    ``if` `(n == 1) ` `        ``return` `mat; ` ` `  `    ``// dp[][] matrix to store the results ` `    ``// of each iteration ` `    ``int` `dp[n][n]; ` `    ``int` `maxSum = INT_MIN, max; ` ` `  `    ``// base case, copying elements of ` `    ``// last row ` `    ``for` `(``int` `j = 0; j < n; j++) ` `        ``dp[n - 1][j] = mat[n - 1][j]; ` ` `  `    ``// building up the dp[][] matrix from ` `    ``// bottom to the top row ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) { ` `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``max = INT_MIN; ` ` `  `            ``// finding the maximum diagonal element in the ` `            ``// (i+1)th row if that cell exists ` `            ``if` `(((j - 1) >= 0) && (max < dp[i + 1][j - 1])) ` `                ``max = dp[i + 1][j - 1]; ` `            ``if` `(((j + 1) < n) && (max < dp[i + 1][j + 1])) ` `                ``max = dp[i + 1][j + 1]; ` ` `  `            ``// adding that 'max' element to the ` `            ``// mat[i][j] element ` `            ``dp[i][j] = mat[i][j] + max; ` `        ``} ` `    ``} ` ` `  `    ``// finding the maximum value from the ` `    ``// first row of dp[][] ` `    ``for` `(``int` `j = 0; j < n; j++) ` `        ``if` `(maxSum < dp[j]) ` `            ``maxSum = dp[j]; ` ` `  `    ``// required maximum sum ` `    ``return` `maxSum; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``int` `mat[SIZE][SIZE] = { { 5, 6, 1, 7 }, ` `                            ``{ -2, 10, 8, -1 }, ` `                            ``{ 3, -7, -9, 11 }, ` `                            ``{ 12, -4, 2, 6 } }; ` `    ``int` `n = 4; ` ` `  `    ``cout << ``"Maximum Sum = "` `         ``<< maxSum(mat, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to find the  ` `// maximum sum path in a matrix ` `import` `java.io.*; ` ` `  `class` `MaxSumPath { ` `//int mat[][]; ` ` `  `// function to find the maximum  ` `// sum path in a matrix ` `static` `int` `maxSum(``int``[][] mat, ``int` `n) ` `{ ` `    ``// if there is a single element only ` `    ``if` `(n == ``1``) ` `        ``return` `mat[``0``][``0``]; ` ` `  `    ``// dp[][] matrix to store the results ` `    ``// of each iteration ` `    ``int` `dp[][] = ``new` `int``[n][n]; ` `    ``int` `maxSum = Integer.MIN_VALUE, max; ` ` `  `    ``// base case, copying elements of ` `    ``// last row ` `    ``for` `(``int` `j = ``0``; j < n; j++) ` `        ``dp[n - ``1``][j] = mat[n - ``1``][j]; ` ` `  `    ``// building up the dp[][] matrix  ` `    ``// from bottom to the top row ` `    ``for` `(``int` `i = n - ``2``; i >= ``0``; i--) { ` `        ``for` `(``int` `j = ``0``; j < n; j++) { ` `            ``max = Integer.MIN_VALUE; ` ` `  `            ``// finding the maximum diagonal  ` `            ``// element in the (i+1)th row  ` `            ``// if that cell exists ` `            ``if` `(((j - ``1``) >= ``0``) &&  ` `                 ``(max < dp[i + ``1``][j - ``1``])) ` `                 ``max = dp[i + ``1``][j - ``1``]; ` `            ``if` `(((j + ``1``) < n) &&  ` `                ``(max < dp[i + ``1``][j + ``1``])) ` `                ``max = dp[i + ``1``][j + ``1``]; ` ` `  `            ``// adding that 'max' element ` `            ``// to the mat[i][j] element ` `            ``dp[i][j] = mat[i][j] + max; ` `        ``} ` `    ``} ` ` `  `    ``// finding the maximum value from ` `    ``// the first row of dp[][] ` `    ``for` `(``int` `j = ``0``; j < n; j++) ` `        ``if` `(maxSum < dp[``0``][j]) ` `            ``maxSum = dp[``0``][j]; ` ` `  `    ``// required maximum sum ` `    ``return` `maxSum; ` `} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main (String[] args) { ` `     `  `    ``int` `mat[][] = { { ``5``, ``6``, ``1``, ``7` `}, ` `                    ``{ -``2``, ``10``, ``8``, -``1` `}, ` `                    ``{ ``3``, -``7``, -``9``, ``11` `}, ` `                    ``{ ``12``, -``4``, ``2``, ``6` `} }; ` `    ``int` `n = ``4``; ` ` `  `    ``System.out.println(``"Maximum Sum = "``+ ` `                        ``maxSum(mat , n)); ` ` `  `    ``} ` `} ` ` `  `// This code is contributed by Prerna Saini `

## Python3

 `# Python3 implementation to find  ` `# the maximum sum path in a matrix  ` ` `  `SIZE``=``10` `INT_MIN``=``-``10000000` ` `  `# function to find the maximum sum ` `# path in a matric  ` `def` `maxSum(mat,n): ` `     `  `    ``#if there is a single elementif  ` `    ``#there is a single element only only  ` `    ``if` `n``=``=``1``: ` `        ``return` `mat[``0``][``0``] ` `         `  `    ``# dp[][] matrix to store the results  ` `    ``# of each iteration  ` `    ``dp``=``[[``0` `for` `i ``in` `range``(n)]``for` `i ``in` `range``(n)] ` `    ``maxSum``=``INT_MIN ` `     `  `    ``# base case, copying elements of  ` `    ``# last row  ` `    ``for` `j ``in` `range``(n): ` `        ``dp[n ``-` `1``][j] ``=` `mat[n ``-` `1``][j] ` `         `  `    ``# building up the dp[][] matrix from  ` `    ``# bottom to the top row ` `    ``for` `i ``in` `range``(n``-``2``,``-``1``,``-``1``): ` `        ``for` `j ``in` `range``(n): ` `            ``maxi``=``INT_MIN ` `             `  `            ``# finding the maximum diagonal  ` `            ``# element in the ` `            ``# (i+1)th row if that cell exists ` `            ``if` `((((j ``-` `1``) >``=` `0``) ``and`  `               ``(maxi < dp[i ``+` `1``][j ``-` `1``]))): ` `                   ``maxi ``=` `dp[i ``+` `1``][j ``-` `1``] ` `            ``if` `((((j ``+` `1``) < n) ``and`  `               ``(maxi < dp[i ``+` `1``][j ``+` `1``]))): ` `                   ``maxi ``=` `dp[i ``+` `1``][j ``+` `1``] ` `                 `  `            ``# adding that 'max' element to the ` `            ``# mat[i][j] element ` `            ``dp[i][j] ``=` `mat[i][j] ``+` `maxi ` `             `  `    ``# finding the maximum value from the ` `    ``# first row of dp[][] ` `    ``for` `j ``in` `range``(n): ` `        ``if` `(maxSum < dp[``0``][j]): ` `            ``maxSum ``=` `dp[``0``][j] ` `             `  `    ``# required maximum sum ` `    ``return` `maxSum ` ` `  `# Driver program to test above  ` `if` `__name__``=``=``'__main__'``: ` `    ``mat``=``[[``5``, ``6``, ``1``, ``7``], ` `        ``[``-``2``, ``10``, ``8``, ``-``1``], ` `        ``[ ``3``, ``-``7``, ``-``9``, ``11` `], ` `        ``[``12``, ``-``4``, ``2``, ``6` `]] ` ` `  `    ``n``=``4` `    ``print``(``"Maximum Sum="``,maxSum(mat,n)) ` `     `  `#This code is contributed by sahilshelangia `

## C#

 `// C# implementation to find the  ` `// maximum sum path in a matrix ` `using` `System; ` ` `  `class` `MaxSumPath  ` `{ ` `    ``//int mat[][]; ` `     `  `    ``// function to find the maximum  ` `    ``// sum path in a matrix ` `    ``static` `int` `maxSum(``int``[,] mat, ``int` `n) ` `    ``{ ` `        ``// if there is a single element only ` `        ``if` `(n == 1) ` `            ``return` `mat[0, 0]; ` `     `  `        ``// dp[][] matrix to store the results ` `        ``// of each iteration ` `        ``int` `[,]dp = ``new` `int``[n, n]; ` `        ``int` `maxSum = ``int``.MinValue, max; ` `     `  `        ``// base case, copying elements of ` `        ``// last row ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``dp[n - 1, j] = mat[n - 1, j]; ` `     `  `        ``// building up the dp[][] matrix  ` `        ``// from bottom to the top row ` `        ``for` `(``int` `i = n - 2; i >= 0; i--) ` `        ``{ ` `            ``for` `(``int` `j = 0; j < n; j++)  ` `            ``{ ` `                ``max = ``int``.MinValue; ` `     `  `                ``// finding the maximum diagonal  ` `                ``// element in the (i+1)th row  ` `                ``// if that cell exists ` `                ``if` `(((j - 1) >= 0) &&  ` `                    ``(max < dp[i + 1, j - 1])) ` `                    ``max = dp[i + 1, j - 1]; ` `                ``if` `(((j + 1) < n) &&  ` `                    ``(max < dp[i + 1, j + 1])) ` `                    ``max = dp[i + 1, j + 1]; ` `     `  `                ``// adding that 'max' element ` `                ``// to the mat[i][j] element ` `                ``dp[i, j] = mat[i, j] + max; ` `            ``} ` `        ``} ` `     `  `        ``// finding the maximum value from ` `        ``// the first row of dp[][] ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``if` `(maxSum < dp[0, j]) ` `                ``maxSum = dp[0, j]; ` `     `  `        ``// required maximum sum ` `        ``return` `maxSum; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main () { ` `     `  `    ``int` `[,]mat = { { 5, 6, 1, 7 }, ` `                    ``{ -2, 10, 8, -1 }, ` `                    ``{ 3, -7, -9, 11 }, ` `                    ``{ 12, -4, 2, 6 } }; ` `    ``int` `n = 4; ` ` `  `    ``Console.WriteLine(``"Maximum Sum = "``+ ` `                        ``maxSum(mat , n)); ` ` `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

## PHP

 `= 0; ``\$i``--)  ` `    ``{ ` `        ``for` `( ``\$j` `= 0; ``\$j` `< ``\$n``; ``\$j``++) ` `        ``{ ` `            ``\$max` `= PHP_INT_MIN; ` ` `  `            ``// finding the maximum  ` `            ``// diagonal element in the ` `            ``// (i+1)th row if that cell  ` `            ``// exists ` `            ``if` `(((``\$j` `- 1) >= 0) ``and`  `                ``(``\$max` `< ``\$dp``[``\$i` `+ 1][``\$j` `- 1])) ` `                 `  `                ``\$max` `= ``\$dp``[``\$i` `+ 1][``\$j` `- 1]; ` `                 `  `            ``if` `(((``\$j` `+ 1) < ``\$n``) ``and` `(``\$max` `<  ` `                      ``\$dp``[``\$i` `+ 1][``\$j` `+ 1])) ` `                       `  `                ``\$max` `= ``\$dp``[``\$i` `+ 1][``\$j` `+ 1]; ` ` `  `            ``// adding that 'max' element to the ` `            ``// mat[i][j] element ` `            ``\$dp``[``\$i``][``\$j``] = ``\$mat``[``\$i``][``\$j``] + ``\$max``; ` `        ``} ` `    ``} ` ` `  `    ``// finding the maximum value from the ` `    ``// first row of dp[][] ` `    ``for` `( ``\$j` `= 0; ``\$j` `< ``\$n``; ``\$j``++) ` `        ``if` `(``\$maxSum` `< ``\$dp``[``\$j``]) ` `            ``\$maxSum` `= ``\$dp``[``\$j``]; ` ` `  `    ``// required maximum sum ` `    ``return` `\$maxSum``; ` `} ` ` `  `    ``// Driver Code ` `    ``\$mat` `= ``array``(``array``(5, 6, 1, 7), ` `                 ``array``(-2, 10, 8, -1), ` `                 ``array``(3, -7, -9, 11), ` `                 ``array``(12, -4, 2, 6)); ` `    ``\$n` `= 4; ` `    ``echo` `"Maximum Sum = "` `        ``, maxSum(``\$mat``, ``\$n``); ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output:

```Maximum Sum = 28
```

Time Complexity: O(n2).
Auxiliary Space: O(n2).

Exercise: Try to solve it in auxiliary space of O(n).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.

Improved By : vt_m, sahilshelangia