Skip to content
Related Articles

Related Articles

Maximum weight path ending at any element of last row in a matrix
  • Difficulty Level : Easy
  • Last Updated : 19 Dec, 2018

Given a matrix of integers where every element represents 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 following 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 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.



C++




// 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)
{
    // creat 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 paht 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 rech
    // 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;
}
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):
      
    # creat 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



<?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) 
{ 
    // creat 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 rech 
    // 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
?>

Output:
Maximum Path Sum : 255

Time complexity : O(N*N)
This article is contributed by Nishant_singh (pintu). 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
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
Previous
Maximum value with the choice of either dividing or considering as it is
Next

Maximum sum in a 2 x n grid such that no two elements are adjacent
Recommended Articles
Page :
Maximum path sum that starting with any cell of 0-th row and ending with any cell of (N-1)-th row
25, Feb 17
Choose maximum weight with given weight and value ratio
19, Jun 17
Count number of paths whose weight is exactly X and has at-least one edge of weight M
04, Jan 19
Length of the longest path ending at vertex V in a Graph
16, Mar 21
Print all possible paths from the first row to the last row in a 2D array
03, Jan 20
Maximum sum of any submatrix of a Matrix which is sorted row-wise and column-wise
10, Aug 20
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Path with smallest product of edges with weight > 0
27, Jan 20
Check if a path exists from a given cell to any boundary element of the Matrix with sum of elements not exceeding K
31, Mar 21
Check if row-major order path of Matrix is palindrome or not
20, Jun 20
Replace every matrix element with maximum of GCD of row or column
01, Jan 17
Find maximum element of each row in a matrix
26, Apr 18
Check if a matrix can be converted to another by repeatedly adding any value to X consecutive elements in a row or column
22, Mar 21
Maximum cost path in an Undirected Graph such that no edge is visited twice in a row
03, Jul 20
Represent a number as the sum of positive numbers ending with 9
01, Sep 20
Element in a matrix starting from which anti-clockwise traversal ends at the last element
28, Mar 19
Find the weight at (Xi, Yi) after M operations in a Matrix
15, Nov 19
Minimum number of flips required such that the last cell of matrix can be reached from any other cell
18, Nov 20
Maximum trace possible for any sub-matrix of the given matrix
12, Mar 19
Find trace of matrix formed by adding Row-major and Column-major order of same matrix
04, Dec 17
Minimize count of adjacent row swaps to convert given Matrix to a Lower Triangular Matrix
06, Oct 20
Check if a given matrix can be converted to another given matrix by row and column exchanges
30, Apr 20
Check if a path exists for a cell valued 1 to reach the bottom right corner of a Matrix before any cell valued 2
07, Sep 20
Maximum weight transformation of a given string
15, Sep 15
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox