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++ program to find the path having the // maximum weight in matrix #include<bits/stdc++.h> 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<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] +
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 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 program to find the path having the // maximum weight in matrix #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;
} /* 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<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] +
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 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;
} // This code is contributed by kothavvsaakash. |
// 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 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# 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 // PHP program to find the path having the // maximum weight in matrix /* Function which return the maximum weight path sum */ function maxCost( $mat , $N )
{ // create 2D matrix to store the sum of the path
$dp = array ( array ()) ;
//memset(dp, 0, sizeof(dp));
$dp [0][0] = $mat [0][0];
// Initialize first column of total weight
// array (dp[i to N][0])
for ( $i =1; $i < $N ; $i ++)
$dp [ $i ][0] = $mat [ $i ][0] + $dp [ $i -1][0];
// Calculate rest path sum of weight matrix
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 ]);
}
// find the max weight path sum to reach
// the last row
$result = 0;
for ( $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
$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 ) ;
// This code is contributed by Ryuga ?> |
<script> // JavaScript Code for Maximum weight path ending at
// any element of last row in a matrix
/* Function which return the maximum weight
path sum */
function maxCost(mat, N)
{
// create 2D matrix to store the sum of
// the path
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];
// Initialize first column of total
// weight array (dp[i to N][0])
for (let i = 1; i < N; i++)
dp[i][0] = mat[i][0] + dp[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++)
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
let result = 0;
for (let i = 0; i < N; i++)
if (result < dp[N-1][i])
result = dp[N-1][i];
// return maximum weight path sum
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> |
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++ program to find the path having the maximum weight in matrix #include<bits/stdc++.h> 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 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# 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 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.
|
# 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))
|
Maximum Path Sum : 255
Time Complexity : O(N*N)
Auxiliary Space: O(1)