Maximum weight path ending at any element of last row in a matrix
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).
- Down Move : (i+1, j)
- 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++
#include<bits/stdc++.h>
using namespace std;
const int MAX = 1000;
int maxCost( int mat[][MAX], int N)
{
int dp[N][N];
memset (dp, 0, sizeof (dp));
dp[0][0] = mat[0][0];
for ( int i=1; i<N; i++)
dp[i][0] = mat[i][0] + dp[i-1][0];
for ( int i=1; i<N; i++)
for ( int j=1; j<i+1&&j<N; j++)
dp[i][j] = mat[i][j] +
max(dp[i-1][j-1], dp[i-1][j]);
int result = 0;
for ( int i=0; i<N; i++)
if (result < dp[N-1][i])
result = dp[N-1][i];
return result;
}
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;
}
|
C
#include <stdio.h>
#include <string.h>
#define MAX 1000
int max( int a, int b)
{
int max = a;
if (max<b)
max = b;
return max;
}
int maxCost( int mat[][MAX], int N)
{
int dp[N][N];
memset (dp, 0, sizeof (dp));
dp[0][0] = mat[0][0];
for ( int i=1; i<N; i++)
dp[i][0] = mat[i][0] + dp[i-1][0];
for ( int i=1; i<N; i++)
for ( int j=1; j<i+1&&j<N; j++)
dp[i][j] = mat[i][j] +
max(dp[i-1][j-1], dp[i-1][j]);
int result = 0;
for ( int i=0; i<N; i++)
if (result < dp[N-1][i])
result = dp[N-1][i];
return result;
}
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;
printf ( "Maximum Path Sum : %d\n" ,maxCost(mat, N));
return 0;
}
|
Java
import java.util.*;
class GFG {
public static int maxCost( int mat[][], int N)
{
int dp[][]= new int [N][N];
dp[ 0 ][ 0 ] = mat[ 0 ][ 0 ];
for ( int i = 1 ; i < N; i++)
dp[i][ 0 ] = mat[i][ 0 ] + dp[i- 1 ][ 0 ];
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]);
int result = 0 ;
for ( int i = 0 ; i < N; i++)
if (result < dp[N- 1 ][i])
result = dp[N- 1 ][i];
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));
}
}
|
Python3
MAX = 1000
def maxCost(mat, N):
dp = [[ 0 for i in range (N)] for j in range (N)]
dp[ 0 ][ 0 ] = mat[ 0 ][ 0 ]
for i in range ( 1 , N):
dp[i][ 0 ] = mat[i][ 0 ] + dp[i - 1 ][ 0 ]
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])
result = 0
for i in range (N):
if (result < dp[N - 1 ][i]):
result = dp[N - 1 ][i]
return result
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))
|
C#
using System;
class GFG {
public static int maxCost( int [,] mat, int N)
{
int [,] dp = new int [N,N];
dp[0,0] = mat[0,0];
for ( int i = 1; i < N; i++)
dp[i,0] = mat[i,0] + dp[i-1,0];
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]);
int result = 0;
for ( int i = 0; i < N; i++)
if (result < dp[N-1,i])
result = dp[N-1,i];
return result;
}
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));
}
}
|
PHP
<?php
function maxCost( $mat , $N )
{
$dp = array ( array ()) ;
$dp [0][0] = $mat [0][0];
for ( $i =1; $i < $N ; $i ++)
$dp [ $i ][0] = $mat [ $i ][0] + $dp [ $i -1][0];
for ( $i =1; $i < $N ; $i ++) {
for ( $j =1; $j < $i +1 && $j < $N ; $j ++)
$dp [ $i ][ $j ] = $mat [ $i ][ $j ] + max( $dp [ $i -1][ $j -1], $dp [ $i -1][ $j ]);
}
$result = 0;
for ( $i =0; $i < $N ; $i ++)
if ( $result < $dp [ $N -1][ $i ])
$result = $dp [ $N -1][ $i ];
return $result ;
}
$mat = array ( array ( 4, 1 ,5 ,6 , 1 ),
array ( 2 ,9 ,2 ,11 ,10 ),
array ( 15,1 ,3 ,15, 2 ),
array ( 16, 92, 41,4,3),
array ( 8, 142, 6, 4, 8 ) );
$N = 5;
echo "Maximum Path Sum : " , maxCost( $mat , $N ) ;
?>
|
Javascript
<script>
function maxCost(mat, N)
{
let dp = new Array(N);
for (let i = 0; i < N; i++)
{
dp[i] = new Array(N);
for (let j = 0; j < N; j++)
{
dp[i][j] = 0;
}
}
dp[0][0] = mat[0][0];
for (let i = 1; i < N; i++)
dp[i][0] = mat[i][0] + dp[i-1][0];
for (let i = 1; i < N; i++)
for (let 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]);
let result = 0;
for (let i = 0; i < N; i++)
if (result < dp[N-1][i])
result = dp[N-1][i];
return result;
}
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;
document.write( "Maximum Path Sum : " +
maxCost(mat, N));
</script>
|
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++
#include<bits/stdc++.h>
using namespace std;
const int MAX = 1000;
int maxCost( int mat[][MAX], int N) {
for ( int i = 1; i < N; i++)
mat[i][0] = mat[i][0] + mat[i - 1][0];
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]);
}
}
int result = 0;
for ( int i = 0; i < N; i++) {
if (result < mat[N - 1][i]) {
result = mat[N - 1][i];
}
}
return result;
}
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
import java.io.*;
class GFG {
public static int MAX = 1000 ;
public static int maxCost( int mat[][], int N) {
for ( int i = 1 ; i < N; i++)
mat[i][ 0 ] = mat[i][ 0 ] + mat[i - 1 ][ 0 ];
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]);
}
}
int result = 0 ;
for ( int i = 0 ; i < N; i++) {
if (result < mat[N - 1 ][i]) {
result = mat[N - 1 ][i];
}
}
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));
}
}
|
C#
using System;
class GFG
{
static int maxCost( int [, ] mat, int N)
{
for ( int i = 1; i < N; i++)
mat[i, 0] = mat[i, 0] + mat[i - 1, 0];
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]);
}
}
int result = 0;
for ( int i = 0; i < N; i++) {
if (result < mat[N - 1, i]) {
result = mat[N - 1, i];
}
}
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));
}
}
|
Javascript
function maxCost(mat, N) {
for (let i = 1; i < N; i++)
mat[i][0] = mat[i][0] + mat[i - 1][0];
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]);
}
}
let result = 0;
for (let i = 0; i < N; i++) {
if (result < mat[N - 1][i]) {
result = mat[N - 1][i];
}
}
return result;
}
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)) ;
|
Python3
def maxCost(mat, N):
for i in range ( 1 , N):
mat[i][ 0 ] = mat[i][ 0 ] + mat[i - 1 ][ 0 ]
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])
result = 0
for i in range (N):
if result < mat[N - 1 ][i]:
result = mat[N - 1 ][i]
return result
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)
Last Updated :
28 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...