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



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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none









PHP














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















<?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. 


?> 



















                        chevron_right







                        filter_none










Output:


Maximum Sum = 28



Time Complexity: O(n2).

Auxiliary Space: O(n2).


Exercise: Try to solve it in auxiliary space of O(n).


GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details 





    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
ayushjauhari14
Check out this Author's contributed articles.
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 Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.


Improved By :  vt_m, sahilshelangia