Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum sum path in a Matrix

  • Difficulty Level : Hard
  • Last Updated : 26 Nov, 2021

Given an n*m matrix, the task is to find the maximum sum of elements of cells starting from the cell (0, 0) to cell (n-1, m-1). 
However, the allowed moves are right, downwards or diagonally right, i.e, from location (i, j) next move can be (i+1, j), or, (i, j+1), or (i+1, j+1). Find the maximum sum of elements satisfying the allowed moves.
Examples: 

Input:
mat[][] = {{100, -350, -200},
           {-100, -300, 700}}
Output: 500
Explanation: 
Path followed is 100 -> -300 -> 700

Input:
mat[][] = {{500, 100, 230},
           {1000, 300, 100},
           {200, 1000, 200}}
Output: 3000
Explanation:
Path followed is 500 -> 1000 -> 300 -> 1000 -> 200

Approach: Dynamic programming is used to solve the above problem in a recursive way.  

  1. Allot a position at the beginning of the matrix at (0, 0).
  2. Check each next allowed position from the current position and select the path with maximum sum.
  3. Take care of the boundaries of the matrix, i.e, if the position reaches the last row or last column then the only possible choice will be right or downwards respectively.
  4. Use a map to store track of all the visiting positions and before visiting any (i, j), check whether or not the position is visited before.
  5. Update the maximum of all possible paths returned by each recursive calls made.
  6. Go till the position reaches the destination cell, i.e, (n-1.m-1).

Below is the implementation of the above approach: 

C++




#include <bits/stdc++.h>
using namespace std;
#define N 100
 
// No of rows and columns
int n, m;
 
// Declaring the matrix of maximum
// 100 rows and 100 columns
int a[N][N];
 
// Variable visited is used to keep
// track of all the visited positions
// Variable dp is used to store
// maximum sum till current position
vector<vector<int> > dp(N, vector<int>(N)),
    visited(N, vector<int>(N));
 
// For storing current sum
int current_sum = 0;
 
// For continuous update of
// maximum sum required
int total_sum = 0;
 
// Function to Input the matrix of size n*m
void inputMatrix()
{
    n = 3;
    m = 3;
    a[0][0] = 500;
    a[0][1] = 100;
    a[0][2] = 230;
    a[1][0] = 1000;
    a[1][1] = 300;
    a[1][2] = 100;
    a[2][0] = 200;
    a[2][1] = 1000;
    a[2][2] = 200;
}
 
// Function to calculate maximum sum of path
int maximum_sum_path(int i, int j)
{
    // Checking boundary condition
    if (i == n - 1 && j == m - 1)
        return a[i][j];
 
    // Checking whether or not (i, j) is visited
    if (visited[i][j])
        return dp[i][j];
 
    // Marking (i, j) is visited
    visited[i][j] = 1;
 
    // Updating the maximum sum till
    // the current position in the dp
    int& total_sum = dp[i][j];
 
    // Checking whether the position hasn't
    // visited the last row or the last column.
    // Making recursive call for all the possible
    // moves from the current cell and then adding the
    // maximum returned by the calls and updating it.
    if (i < n - 1 & j < m - 1) {
        int current_sum = max(maximum_sum_path(i, j + 1),
                              max(
                                  maximum_sum_path(i + 1, j + 1),
                                  maximum_sum_path(i + 1, j)));
        total_sum = a[i][j] + current_sum;
    }
 
    // Checking whether
    // position has reached last row
    else if (i == n - 1)
        total_sum = a[i][j]
                    + maximum_sum_path(i, j + 1);
 
    // If the position is in the last column
    else
        total_sum = a[i][j]
                    + maximum_sum_path(i + 1, j);
 
    // Returning the updated maximum value
    return dp[i][j] = total_sum;
}
 
// Driver Code
int main()
{
    inputMatrix();
 
    // Calling the implemented function
    int maximum_sum = maximum_sum_path(0, 0);
 
    cout << maximum_sum;
    return 0;
}
Java



class GFG{
     
static final int N = 100;
 
// No of rows and columns
static int n, m;
 
// Declaring the matrix of maximum
// 100 rows and 100 columns
static int a[][] = new int[N][N];
 
// Variable visited is used to keep
// track of all the visited positions
// Variable dp is used to store
// maximum sum till current position
static int dp[][] = new int[N][N];
static int visited[][] = new int[N][N];
 
// For storing current sum
static int current_sum = 0;
 
// For continuous update of
// maximum sum required
static int total_sum = 0;
 
// Function to Input the matrix
// of size n*m
static void inputMatrix()
{
    n = 3;
    m = 3;
    a[0][0] = 500;
    a[0][1] = 100;
    a[0][2] = 230;
    a[1][0] = 1000;
    a[1][1] = 300;
    a[1][2] = 100;
    a[2][0] = 200;
    a[2][1] = 1000;
    a[2][2] = 200;
}
 
// Function to calculate maximum sum of path
static int maximum_sum_path(int i, int j)
{
     
    // Checking boundary condition
    if (i == n - 1 && j == m - 1)
        return a[i][j];
 
    // Checking whether or not
    // (i, j) is visited
    if (visited[i][j] != 0)
        return dp[i][j];
 
    // Marking (i, j) is visited
    visited[i][j] = 1;
 
    int total_sum = 0;
 
    // Checking whether the position hasn't
    // visited the last row or the last column.
    // Making recursive call for all the possible
    // moves from the current cell and then adding the
    // maximum returned by the calls and updating it.
    if (i < n - 1 & j < m - 1)
    {
        int current_sum = Math.max(
                          maximum_sum_path(i, j + 1),
                          Math.max(
                          maximum_sum_path(i + 1, j + 1),
                          maximum_sum_path(i + 1, j)));
        total_sum = a[i][j] + current_sum;
    }
 
    // Checking whether position
    // has reached last row
    else if (i == n - 1)
        total_sum = a[i][j] +
                    maximum_sum_path(i, j + 1);
 
    // If the position is in the last column
    else
        total_sum = a[i][j] +
                    maximum_sum_path(i + 1, j);
 
    // Updating the maximum sum till
    // the current position in the dp
    dp[i][j] = total_sum;
 
    // Returning the updated maximum value
    return total_sum;
}
 
// Driver Code
public static void main(String[] args)
{
    inputMatrix();
 
    // Calling the implemented function
    int maximum_sum = maximum_sum_path(0, 0);
 
    System.out.println(maximum_sum);
}
}
 
// This code is contributed by jrishabh99
C#



// C# program to implement
// the above approach
using System;
class GFG{
 
static readonly int N = 100;
 
// No of rows and columns
static int n, m;
 
// Declaring the matrix of maximum
// 100 rows and 100 columns
static int[,]a = new int[N, N];
 
// Variable visited is used to keep
// track of all the visited positions
// Variable dp is used to store
// maximum sum till current position
static int [,]dp = new int[N, N];
static int [,]visited = new int[N, N];
 
// For storing current sum
static int current_sum = 0;
 
// For continuous update of
// maximum sum required
static int total_sum = 0;
 
// Function to Input the matrix
// of size n*m
static void inputMatrix()
{
  n = 3;
  m = 3;
  a[0, 0] = 500;
  a[0, 1] = 100;
  a[0, 2] = 230;
  a[1, 0] = 1000;
  a[1, 1] = 300;
  a[1, 2] = 100;
  a[2, 0] = 200;
  a[2, 1] = 1000;
  a[2, 2] = 200;
}
 
// Function to calculate maximum
// sum of path
static int maximum_sum_path(int i,
                            int j)
{
  // Checking boundary condition
  if (i == n - 1 && j == m - 1)
    return a[i, j];
 
  // Checking whether or not
  // (i, j) is visited
  if (visited[i, j] != 0)
    return dp[i, j];
 
  // Marking (i, j) is visited
  visited[i, j] = 1;
 
  int total_sum = 0;
 
  // Checking whether the position
  // hasn't visited the last row
  // or the last column.
  // Making recursive call for all
  // the possible moves from the
  // current cell and then adding the
  // maximum returned by the calls
  // and updating it.
  if (i < n - 1 & j < m - 1)
  {
    int current_sum = Math.Max(maximum_sum_path(i, j + 1),
                      Math.Max(maximum_sum_path(i + 1,
                                                j + 1),
                               maximum_sum_path(i + 1, j)));
    total_sum = a[i, j] + current_sum;
  }
 
  // Checking whether position
  // has reached last row
  else if (i == n - 1)
    total_sum = a[i, j] +
                maximum_sum_path(i, j + 1);
 
  // If the position is
  // in the last column
  else
    total_sum = a[i, j] +
                maximum_sum_path(i + 1, j);
 
  // Updating the maximum
  // sum till the current
  // position in the dp
  dp[i, j] = total_sum;
 
  // Returning the updated
  // maximum value
  return total_sum;
}
 
// Driver Code
public static void Main(String[] args)
{
  inputMatrix();
 
  // Calling the implemented function
  int maximum_sum = maximum_sum_path(0, 0);
 
  Console.WriteLine(maximum_sum);
}
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
    // Javascript program to implement the above approach
     
    let N = 100;
  
    // No of rows and columns
    let n, m;
 
    // Declaring the matrix of maximum
    // 100 rows and 100 columns
    let a = new Array(N);
 
    // Variable visited is used to keep
    // track of all the visited positions
    // Variable dp is used to store
    // maximum sum till current position
    let dp = new Array(N);
    let visited = new Array(N);
    for(let i = 0; i < N; i++)
    {
        a[i] = new Array(N);
        dp[i] = new Array(N);
        visited[i] = new Array(N);
        for(let j = 0; j < N; j++)
        {
            a[i][j] = 0;
            dp[i][j] = 0;
            visited[i][j] = 0;
        }
    }
 
    // For storing current sum
    let current_sum = 0;
 
    // For continuous update of
    // maximum sum required
    let total_sum = 0;
 
    // Function to Input the matrix
    // of size n*m
    function inputMatrix()
    {
        n = 3;
        m = 3;
        a[0][0] = 500;
        a[0][1] = 100;
        a[0][2] = 230;
        a[1][0] = 1000;
        a[1][1] = 300;
        a[1][2] = 100;
        a[2][0] = 200;
        a[2][1] = 1000;
        a[2][2] = 200;
    }
 
    // Function to calculate maximum sum of path
    function maximum_sum_path(i, j)
    {
 
        // Checking boundary condition
        if (i == n - 1 && j == m - 1)
            return a[i][j];
 
        // Checking whether or not
        // (i, j) is visited
        if (visited[i][j] != 0)
            return dp[i][j];
 
        // Marking (i, j) is visited
        visited[i][j] = 1;
 
        let total_sum = 0;
 
        // Checking whether the position hasn't
        // visited the last row or the last column.
        // Making recursive call for all the possible
        // moves from the current cell and then adding the
        // maximum returned by the calls and updating it.
        if (i < n - 1 & j < m - 1)
        {
            let current_sum = Math.max(
                              maximum_sum_path(i, j + 1),
                              Math.max(
                              maximum_sum_path(i + 1, j + 1),
                              maximum_sum_path(i + 1, j)));
            total_sum = a[i][j] + current_sum;
        }
 
        // Checking whether position
        // has reached last row
        else if (i == n - 1)
            total_sum = a[i][j] + maximum_sum_path(i, j + 1);
 
        // If the position is in the last column
        else
            total_sum = a[i][j] + maximum_sum_path(i + 1, j);
 
        // Updating the maximum sum till
        // the current position in the dp
        dp[i][j] = total_sum;
 
        // Returning the updated maximum value
        return total_sum;
    }
     
    inputMatrix();
  
    // Calling the implemented function
    let maximum_sum = maximum_sum_path(0, 0);
  
    document.write(maximum_sum);
 
// This code is contributed by suresh07.
</script>
Python3



N=100
 
# No of rows and columns
n, m=-1,-1
 
# Declaring the matrix of maximum
# 100 rows and 100 columns
a=[[-1]*N for _ in range(N)]
 
# Variable visited is used to keep
# track of all the visited positions
# Variable dp is used to store
# maximum sum till current position
dp,visited=[[-1]*N for _ in range(N)],[[False]*N for _ in range(N)]
 
# For storing current sum
current_sum = 0
 
# For continuous update of
# maximum sum required
total_sum = 0
 
# Function to Input the matrix of size n*m
def inputMatrix():
    global n, m
    n = 3
    m = 3
    a[0][0] = 500
    a[0][1] = 100
    a[0][2] = 230
    a[1][0] = 1000
    a[1][1] = 300
    a[1][2] = 100
    a[2][0] = 200
    a[2][1] = 1000
    a[2][2] = 200
 
 
# Function to calculate maximum sum of path
def maximum_sum_path(i, j):
    global total_sum
    # Checking boundary condition
    if (i == n - 1 and j == m - 1):
        return a[i][j]
 
    # Checking whether or not (i, j) is visited
    if (visited[i][j]):
        return dp[i][j]
 
    # Marking (i, j) is visited
    visited[i][j] = True
 
    # Updating the maximum sum till
    # the current position in the dp
    total_sum = dp[i][j]
 
    # Checking whether the position hasn't
    # visited the last row or the last column.
    # Making recursive call for all the possible
    # moves from the current cell and then adding the
    # maximum returned by the calls and updating it.
    if (i < n - 1 and j < m - 1) :
        current_sum = max(maximum_sum_path(i, j + 1),
                              max(
                                  maximum_sum_path(i + 1, j + 1),
                                  maximum_sum_path(i + 1, j)))
        total_sum = a[i][j] + current_sum
     
 
    # Checking whether
    # position has reached last row
    elif (i == n - 1):
        total_sum = a[i][j] + maximum_sum_path(i, j + 1)
 
    # If the position is in the last column
    else:
        total_sum = a[i][j] + maximum_sum_path(i + 1, j)
 
    # Returning the updated maximum value
    dp[i][j] = total_sum
    return total_sum
 
 
# Driver Code
if __name__ == '__main__':
    inputMatrix()
 
    # Calling the implemented function
    maximum_sum = maximum_sum_path(0, 0)
 
    print(maximum_sum)
Output
3000
Time Complexity: O(N*M)
Auxiliary Space: O(N*M)

My Personal Notes
arrow_drop_up
Next

Maximum path sum in matrix
Recommended Articles
Page :
Maximum path sum in matrix
24, Jul 17
Maximum sum path in a matrix from top to bottom and back
07, May 19
Paths from entry to exit in matrix and maximum path sum
28, May 19
Find maximum path sum in a 2D matrix when exactly two left moves are allowed
28, 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 sum path in a matrix from top to bottom
02, Dec 17
Construct a Tree whose sum of nodes of all the root to leaf path is not divisible by the count of nodes in that path
19, Mar 21
Maximum decimal value path in a binary matrix
17, Dec 16
Find maximum path length in a binary matrix
14, Nov 18
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
Maximum weight path ending at any element of last row in a matrix
13, Nov 16
Maximize path sum from top-left cell to all other cells of a given Matrix
06, Oct 20
Maximise matrix sum by following the given Path
28, May 19
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
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
Generate matrix from given Sparse Matrix using Linked List and reconstruct the Sparse Matrix
19, Apr 21
Maximum path sum for each position with jumps under divisibility condition
05, Jan 17
Maximum path sum in a triangle.
09, Feb 17
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
Maximum sum of a path in a Right Number Triangle
16, Apr 17
Maximum path sum in the given arrays with at most K jumps
24, Apr 20
Maximum path sum in an Inverted triangle | SET 2
15, Jan 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
skylags
@skylags
Vote for difficulty
Current difficulty :
Hard





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!