# Maximum weight path ending at any element of last row in a matrix

• Difficulty Level : Easy
• Last Updated : 28 Jan, 2023

Given a matrix of integers where every element represents the weight of the cell. Find the path having the maximum weight in matrix [N X N]. Path Traversal Rules are:

• It should begin from top left element.
• The path can end at any element of last row.
• We can move to follow two cells from a cell (i, j).
1. Down Move : (i+1, j)
2. Diagonal Move : (i+1, j+1)

Examples:

```Input : N = 5
mat[5][5] = {{ 4, 2 ,3 ,4 ,1 },
{ 2 , 9 ,1 ,10 ,5 },
{15, 1 ,3 , 0 ,20 },
{16 ,92, 41, 44 ,1},
{8, 142, 6, 4, 8} };
Output : 255
Path with max weight : 4 + 2 +15 + 92 + 142 = 255                 ```

The above problem can be recursively defined.

```Let maxCost(i, j) be the cost maximum cost to
reach mat[i][j].  Since end point can be any point
in last row, we finally return maximum of all values
maxCost(N-1, j) where j varies from 0 to N-1.

If i == 0 and j == 0
maxCost(0, 0) = mat[0][0]

// We can traverse through first column only by
// down move
Else if j = 0
maxCost(i, 0) = maxCost(i-1, 0) + mat[i][0]

// In other cases, a cell mat[i][j] can be reached
// through previous two cells ma[i-1][j] and
// mat[i-1][j-1]
Else
maxCost(i, j) = mat[i][j] + max(maxCost(i-1, j),
maxCost(i-1, j-1)),```

If we draw the recursion tree of above recursive solution, we can observe overlapping subproblems. Since the problem has overlapping subproblems, we can solve it efficiently using Dynamic Programming. Below is Dynamic Programming based solution.

Implementation:

## C++

 `// C++ program to find the path having the``// maximum weight in matrix``#include``using` `namespace` `std;``const` `int` `MAX = 1000;` `/* Function which return the maximum weight``   ``path sum */``int` `maxCost(``int` `mat[][MAX], ``int` `N)``{``    ``// create 2D matrix to store the sum of the path``    ``int` `dp[N][N];``    ``memset``(dp, 0, ``sizeof``(dp));` `    ``dp[0][0] = mat[0][0];` `    ``// Initialize first column of total weight``    ``// array (dp[i to N][0])``    ``for` `(``int` `i=1; i

## C

 `// C program to find the path having the``// maximum weight in matrix``#include ``#include ` `#define MAX 1000` `int` `max(``int` `a, ``int` `b)``{``  ``int` `max = a;``  ``if``(max

## Java

 `// Java Code for Maximum weight path ending at``// any element of last row in a matrix``import` `java.util.*;` `class` `GFG {``    ` `    ``/* Function which return the maximum weight``       ``path sum */``    ``public` `static` `int` `maxCost(``int` `mat[][], ``int` `N)``    ``{``        ``// create 2D matrix to store the sum of``        ``// the path``        ``int` `dp[][]=``new` `int``[N][N];``        ` `        ``dp[``0``][``0``] = mat[``0``][``0``];``     ` `        ``// Initialize first column of total``        ``// weight array (dp[i to N][0])``        ``for` `(``int` `i = ``1``; i < N; i++)``            ``dp[i][``0``] = mat[i][``0``] + dp[i-``1``][``0``];``     ` `        ``// Calculate rest path sum of weight matrix``        ``for` `(``int` `i = ``1``; i < N; i++)``           ``for` `(``int` `j = ``1``; j < i + ``1` `&& j < N; j++)``              ``dp[i][j] = mat[i][j] +``                        ``Math.max(dp[i-``1``][j-``1``],``                                 ``dp[i-``1``][j]);``     ` `        ``// find the max weight path sum to reach``        ``// the last row``        ``int` `result = ``0``;``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``if` `(result < dp[N-``1``][i])``                ``result = dp[N-``1``][i];``     ` `        ``// return maximum weight path sum``        ``return` `result;``    ``}``    ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `mat[][] = {  { ``4``, ``1` `,``5` `,``6` `, ``1` `},``                ``{ ``2` `,``9` `,``2` `,``11` `,``10` `},``                ``{ ``15``,``1` `,``3` `,``15``, ``2` `},``                ``{ ``16``, ``92``, ``41``,``4``,``3``},``                ``{ ``8``, ``142``, ``6``, ``4``, ``8` `}``            ``};``            ``int` `N = ``5``;``           ``System.out.println(``"Maximum Path Sum : "``+``                               ``maxCost(mat, N));``    ``}``}``// This code is contributed by Arnav Kr. Mandal. `

## Python3

 `# Python3 program to find the path``# having the maximum weight in matrix` `MAX` `=` `1000` `# Function which return the``# maximum weight path sum``def` `maxCost(mat, N):``    ` `    ``# create 2D matrix to store the sum of the path``    ``dp ``=` `[[``0` `for` `i ``in` `range``(N)] ``for` `j ``in` `range``(N)]` `    ``dp[``0``][``0``] ``=` `mat[``0``][``0``]` `    ``# Initialize first column of total weight``    ``# array (dp[i to N][0])``    ``for` `i ``in` `range``(``1``, N):``        ``dp[i][``0``] ``=` `mat[i][``0``] ``+` `dp[i ``-` `1``][``0``]` `    ``# Calculate rest path sum of weight matrix``    ``for` `i ``in` `range``(``1``, N):``        ``for` `j ``in` `range``(``1``, ``min``(i ``+` `1``, N)):``            ``dp[i][j] ``=` `mat[i][j] ``+` `\``                       ``max``(dp[i ``-` `1``][j ``-` `1``],``                           ``dp[i ``-` `1``][j])` `    ``# find the max weight path sum to reach``    ``# the last row``    ``result ``=` `0``    ``for` `i ``in` `range``(N):``        ``if` `(result < dp[N ``-` `1``][i]):``            ``result ``=` `dp[N ``-` `1``][i]` `    ``# return maximum weight path sum``    ``return` `result` `# Driver Program` `mat ``=` `[ [``4``, ``1` `,``5` `,``6` `, ``1``],``        ``[``2` `,``9` `,``2` `,``11` `,``10``],``        ``[``15``,``1` `,``3` `,``15``, ``2``],``        ``[``16``, ``92``, ``41``,``4``,``3``],``        ``[``8``, ``142``, ``6``, ``4``, ``8``]]` `N ``=` `5``print``(``'Maximum Path Sum :'``, maxCost(mat, N))` `# This code is contributed by Soumen Ghosh.`

## C#

 `// C# Code for Maximum weight path``// ending at any element of last``// row in a matrix``using` `System;` `class` `GFG {``    ` `    ``/* Function which return the``    ``maximum weight path sum */``    ``public` `static` `int` `maxCost(``int` `[,] mat, ``int` `N)``    ``{``        ` `        ``// create 2D matrix to store the``        ``// sum of the path``        ``int` `[,] dp = ``new` `int``[N,N];``        ` `        ``dp[0,0] = mat[0,0];``    ` `        ``// Initialize first column of total``        ``// weight array (dp[i to N][0])``        ``for` `(``int` `i = 1; i < N; i++)``            ``dp[i,0] = mat[i,0] + dp[i-1,0];``    ` `        ``// Calculate rest path sum of weight matrix``        ``for` `(``int` `i = 1; i < N; i++)``            ``for` `(``int` `j = 1; j < i + 1 && j < N; j++)``                ``dp[i,j] = mat[i,j] +``                   ``Math.Max(dp[i-1,j-1], dp[i-1,j]);``    ` `        ``// find the max weight path sum to reach``        ``// the last row``        ``int` `result = 0;``        ` `        ``for` `(``int` `i = 0; i < N; i++)``            ``if` `(result < dp[N-1,i])``                ``result = dp[N-1,i];``    ` `        ``// return maximum weight path sum``        ``return` `result;``    ``}``    ` `    ``/* Driver program to test above function */``    ``public` `static` `void` `Main()``    ``{``        ``int` `[,] mat = { { 4, 1 ,5 ,6 , 1 },``                        ``{ 2 ,9 ,2 ,11 ,10 },``                        ``{ 15,1 ,3 ,15, 2 },``                        ``{ 16, 92, 41,4,3},``                        ``{ 8, 142, 6, 4, 8 }``                      ``};``        ``int` `N = 5;``        ` `        ``Console.Write(``"Maximum Path Sum : "``                           ``+ maxCost(mat, N));``    ``}``}` `// This code is contributed by KRV.`

## PHP

 ``

## Javascript

 ``

Output

`Maximum Path Sum : 255`

Time Complexity: O(N*N)
Auxiliary Space: O(N*N)

Method – 2 O(1) extra space solution

In the above solution, we use an extra dp array to store ans for a particular dp state but here we use input mat as dp so we don’t need that extra N*N space so this solution works in O(1) space complexity.

## C++

 `// C++ program to find the path having the maximum weight in matrix``#include``using` `namespace` `std;``const` `int` `MAX = 1000;` `// Function which return the maximum weight path sum``int` `maxCost(``int` `mat[][MAX], ``int` `N) {` `    ``// Initialize first column of total weight array (dp[i to N][0])``    ``for` `(``int` `i = 1; i < N; i++)``        ``mat[i][0] = mat[i][0] + mat[i - 1][0];` `    ``// Calculate rest path sum of weight matrix``    ``for` `(``int` `i = 1; i < N; i++) {``        ``for` `(``int` `j = 1; j < i + 1 && j < N; j++) {``            ``mat[i][j] = mat[i][j] + max(mat[i - 1][j - 1], mat[i - 1][j]);``        ``}``    ``}` `    ``// find the max weight path sum to reach the last row``    ``int` `result = 0;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(result < mat[N - 1][i]) {``            ``result = mat[N - 1][i];``        ``}``    ``}` `    ``// return maximum weight path sum``    ``return` `result;``}` `// Driver program``int` `main()``{``    ``int` `mat[MAX][MAX] = {  { 4, 1 , 5 , 6 , 1 },``        ``{ 2 , 9 , 2 , 11 , 10 },``        ``{ 15, 1 , 3 , 15, 2 },``        ``{ 16, 92, 41, 4, 3},``        ``{ 8, 142, 6, 4, 8 }``    ``};``    ``int` `N = 5;``    ``cout << ``"Maximum Path Sum : "` `<< maxCost(mat, N) << endl;``    ``return` `0;``}`

## Java

 `// Java program to find the path having the maximum weight in matrix``import` `java.io.*;` `class` `GFG {``  ``public` `static` `int` `MAX = ``1000``;` `  ``// Function which return the maximum weight path sum``  ``public` `static` `int` `maxCost(``int` `mat[][], ``int` `N) {` `    ``// Initialize first column of total weight array (dp[i to N][0])``    ``for` `(``int` `i = ``1``; i < N; i++)``      ``mat[i][``0``] = mat[i][``0``] + mat[i - ``1``][``0``];` `    ``// Calculate rest path sum of weight matrix``    ``for` `(``int` `i = ``1``; i < N; i++) {``      ``for` `(``int` `j = ``1``; j < i + ``1` `&& j < N; j++) {``        ``mat[i][j] = mat[i][j] + Math.max(mat[i - ``1``][j - ``1``], mat[i - ``1``][j]);``      ``}``    ``}` `    ``// find the max weight path sum to reach the last row``    ``int` `result = ``0``;``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``if` `(result < mat[N - ``1``][i]) {``        ``result = mat[N - ``1``][i];``      ``}``    ``}` `    ``// return maximum weight path sum``    ``return` `result;``  ``}` `  ``public` `static` `void` `main(String[] args) {` `    ``int``[][] mat = {  { ``4``, ``1` `, ``5` `, ``6` `, ``1` `},``                   ``{ ``2` `, ``9` `, ``2` `, ``11` `, ``10` `},``                   ``{ ``15``, ``1` `, ``3` `, ``15``, ``2` `},``                   ``{ ``16``, ``92``, ``41``, ``4``, ``3``},``                   ``{ ``8``, ``142``, ``6``, ``4``, ``8` `}``                  ``};``    ``int` `N = ``5``;``    ``System.out.println(``"Maximum Path Sum : "` `+ maxCost(mat, N));``  ``}``}` `// This code is contributed by ajaymakvana.`

## C#

 `// C# program to find the path having the maximum weight in``// matrix``using` `System;``class` `GFG``{``  ` `  ``// Function which return the maximum weight path sum``  ``static` `int` `maxCost(``int``[, ] mat, ``int` `N)``  ``{` `    ``// Initialize first column of total weight array``    ``// (dp[i to N][0])``    ``for` `(``int` `i = 1; i < N; i++)``      ``mat[i, 0] = mat[i, 0] + mat[i - 1, 0];` `    ``// Calculate rest path sum of weight matrix``    ``for` `(``int` `i = 1; i < N; i++) {``      ``for` `(``int` `j = 1; j < i + 1 && j < N; j++) {``        ``mat[i, j] = mat[i, j]``          ``+ Math.Max(mat[i - 1, j - 1],``                     ``mat[i - 1, j]);``      ``}``    ``}` `    ``// find the max weight path sum to reach the last row``    ``int` `result = 0;``    ``for` `(``int` `i = 0; i < N; i++) {``      ``if` `(result < mat[N - 1, i]) {``        ``result = mat[N - 1, i];``      ``}``    ``}` `    ``// return maximum weight path sum``    ``return` `result;``  ``}` `  ``static` `void` `Main()``  ``{``    ``int``[, ] mat = { { 4, 1, 5, 6, 1 },``                   ``{ 2, 9, 2, 11, 10 },``                   ``{ 15, 1, 3, 15, 2 },``                   ``{ 16, 92, 41, 4, 3 },``                   ``{ 8, 142, 6, 4, 8 } };``    ``int` `N = 5;``    ``Console.Write(``"Maximum Path Sum : "``                  ``+ maxCost(mat, N));``  ``}``}` `// This code is contributed by garg28harsh.`

## Javascript

 `// javascript program to find the path having the maximum weight in matrix` `// Function which return the maximum weight path sum``function` `maxCost(mat,  N) {` `    ``// Initialize first column of total weight array (dp[i to N][0])``    ``for` `(let i = 1; i < N; i++)``        ``mat[i][0] = mat[i][0] + mat[i - 1][0];` `    ``// Calculate rest path sum of weight matrix``    ``for` `(let i = 1; i < N; i++) {``        ``for` `(let j = 1; j < i + 1 && j < N; j++) {``            ``mat[i][j] = mat[i][j] + Math.max(mat[i - 1][j - 1], mat[i - 1][j]);``        ``}``    ``}` `    ``// find the max weight path sum to reach the last row``    ``let result = 0;``    ``for` `(let i = 0; i < N; i++) {``        ``if` `(result < mat[N - 1][i]) {``            ``result = mat[N - 1][i];``        ``}``    ``}` `    ``// return maximum weight path sum``    ``return` `result;``}` `// Driver program` `    ``let mat = [[ 4, 1 , 5 , 6 , 1 ],``        ``[ 2 , 9 , 2 , 11 , 10 ],``        ``[ 15, 1 , 3 , 15, 2],``        ``[ 16, 92, 41, 4, 3],``        ``[ 8, 142, 6, 4, 8 ]];``    ``let N = 5;``    ``console.log(``"Maximum Path Sum : "` `+ maxCost(mat, N)) ;``    ` `    ``// This code is contributed by garg28harsh.`

## Python3

 `# Python program to find the path having the maximum weight in matrix``# Function which return the maximum weight path sum``def` `maxCost(mat, N):``    ``# Initialize first column of total weight array (dp[i to N][0])``    ``for` `i ``in` `range``(``1``, N):``        ``mat[i][``0``] ``=` `mat[i][``0``] ``+` `mat[i``-``1``][``0``]` `    ``# Calculate rest path sum of weight matrix``    ``for` `i ``in` `range``(``1``, N):``        ``for` `j ``in` `range``(``1``, i``+``1``):``            ``mat[i][j] ``=` `mat[i][j] ``+` `max``(mat[i``-``1``][j``-``1``], mat[i ``-` `1``][j])` `    ``# find the max weight path sum to reach the last row``    ``result ``=` `0``    ``for` `i ``in` `range``(N):``        ``if` `result < mat[N``-``1``][i]:``            ``result ``=` `mat[N``-``1``][i]` `    ``# return maximum weight path sum``    ``return` `result` `# Driver program``if` `__name__ ``=``=` `"__main__"``:``    ``mat ``=` `[[``4``, ``1``, ``5``, ``6``, ``1``],``           ``[``2``, ``9``, ``2``, ``11``, ``10``],``           ``[``15``, ``1``, ``3``, ``15``, ``2``],``           ``[``16``, ``92``, ``41``, ``4``, ``3``],``           ``[``8``, ``142``, ``6``, ``4``, ``8``]``           ``]` `    ``N ``=` `5``    ``print``(``"Maximum Path Sum: "``, maxCost(mat, N))`

Output

`Maximum Path Sum : 255`

Time Complexity : O(N*N)
Auxiliary Space: O(1)

This article is contributed by Nishant_singh (pintu). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up