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 <bits/stdc++.h> 
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[0][0]; 
  
    // 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[0][j]) 
            maxSum = dp[0][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

<?php 
// PHP implementation to find  
// the maximum sum path in a matrix 
  
$SIZE = 10; 
  
// function to find the maximum sum 
// path in a matric 
function maxSum( $mat, $n) 
{ 
      
    // if there is a single 
    // element only 
    if ($n == 1) 
        return $mat[0][0]; 
  
    // dp[][] matrix to store the results 
    // of each iteration 
    $dp = array(array()); 
    $maxSum = PHP_INT_MIN; 
    $max; 
  
    // base case, copying elements of 
    // last row 
    for($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 ( $i = $n - 2; $i >= 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[0][$j]) 
            $maxSum = $dp[0][$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(n²).
Auxiliary Space: O(n²).

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

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

C++

Java

Python3

C#

PHP

Recommended Posts: