Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum sum path in a matrix from top to bottom

  • Difficulty Level : Medium
  • Last Updated : 08 Dec, 2021

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




// 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 matrix
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 matrix
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 matrix
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.
?>
Javascript



<script>
 
// JavaScript implementation to find the
// maximum sum path in a matrix
 
// Function to find the maximum
// sum path in a matrix
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
    let dp = new Array(n);
      
    // Loop to create 2D array using 1D array
    for(var i = 0; i < dp.length; i++)
    {
        dp[i] = new Array(2);
    }
     
    let maxSum = Number.MIN_VALUE, max;
   
    // Base case, copying elements of
    // last row
    for(let 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(let i = n - 2; i >= 0; i--)
    {
        for(let j = 0; j < n; j++)
        {
            max = Number.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(let j = 0; j < n; j++)
        if (maxSum < dp[0][j])
            maxSum = dp[0][j];
   
    // Required maximum sum
    return maxSum;
}
   
// Driver Code
let mat = [ [ 5, 6, 1, 7 ],
            [ -2, 10, 8, -1 ],
            [ 3, -7, -9, 11 ],
            [ 12, -4, 2, 6 ] ];
let n = 4;
 
document.write("Maximum Sum = "+
               maxSum(mat , n));
                
// This code is contributed by sanjoy_62
 
</script>
Output: 
Maximum Sum = 28
Time Complexity: O(n2). 
Auxiliary Space: O(n2).
Exercise: Try to solve it in auxiliary space of O(n).
 

My Personal Notes
arrow_drop_up
Previous
Maximum path sum in matrix
Next

Maximum sum path in a matrix from top to bottom and back
Recommended Articles
Page :
Maximum sum path in a matrix from top to bottom and back
07, May 19
Maximum sum path in a matrix from top-left to bottom-right
10, Sep 20
Maximum path sum from top left to bottom right of a matrix passing through one of the given cells
15, Jun 21
Maximum XOR of a path from top-left to bottom-right cell of given Matrix
25, Oct 20
Maximum non-negative product of a path from top left to bottom right of given Matrix
23, Nov 20
Lexicographically largest prime path from top-left to bottom-right in a matrix
16, Oct 18
Minimum number of flips required such that a Binary Matrix doesn't contain any path from the top left to the bottom right consisting only of 0s
29, Jun 21
Shortest path in a Matrix from top-left to bottom right-corner with neighbors exceeding at most K
24, Nov 21
Maximum points from top left of matrix to bottom right and return back
01, Oct 17
Maximum points by traversing from top left of Matrix to bottom right by two persons
09, Aug 21
Find maximum sum from top to bottom row with no adjacent diagonal elements
31, Mar 20
Print all palindromic paths from top left to bottom right in a matrix
20, Sep 17
Minimum cost to reach from the top-left to the bottom-right corner of a matrix
06, Jan 20
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths
20, Jun 20
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths | Set 2
29, Jul 20
Minimize count of unique paths from top left to bottom right of a Matrix by placing K 1s
02, Sep 20
Minimize flips required to make all shortest paths from top-left to bottom-right of a binary matrix equal to S
04, Sep 20
Count all possible paths from top left to bottom right of a Matrix without crossing the diagonal
07, Sep 20
Print matrix elements from top-left to bottom right in diagonally upward manner
23, Nov 20
Minimum steps to convert all top left to bottom right paths in Matrix as palindrome | Set 2
15, Jul 20
Maximize trailing zeros in product from top left to bottom right of given Matrix
27, Oct 20
Print all possible paths from top left to bottom right of a mXn matrix
22, Dec 13
Print all paths from top left to bottom right in a matrix with four moves allowed
25, Dec 18
Count all possible paths from top left to bottom right of a mXn matrix
31, Dec 13
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ayushjauhari14
@ayushjauhari14
Vote for difficulty
Current difficulty :
Medium





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

Start Your Coding Journey Now!