Related Articles

Related Articles

Maximize path sum from top-left cell to all other cells of a given Matrix
  • Last Updated : 01 Nov, 2020

Given a matrix, mat[][] of dimensions N * M, the task is to find the maximum path sum from the top-left cell (0, 0) to all other cells of the given matrix. Only possible moves from any cell (i, j) is (i + 1, j) and (i, j + 1).

Examples:

Input: mat[][] = {{3, 2, 1}, {6, 5, 4}, {7, 8, 9}}
Output:
3 5 6
9 14 18
16 24 33
Explanation:
Path from (0, 0) to (0, 1) with maximum sum is (0, 0) → (0, 1)
Path from (0, 0) to (0, 2) with maximum sum is (0, 0) → (0, 1) → (0, 2)
Path from (0, 0) to (1, 0) with maximum sum is (0, 0) → (1, 0)
Path from (0, 0) to (1, 1) with maximum sum is (0, 0) → (1, 0) → (1, 1)
Path from (0, 0) to (1, 2) with maximum sum is (0, 0) → (1, 0) → (1, 2)
Path from (0, 0) to (2, 0) with maximum sum is (0, 0) → (2, 0)
Path from (0, 0) to (2, 1) with maximum sum is (0, 0) → (1, 0) → (2, 0) → (2, 1)
Path from (0, 0) to (2, 2) with maximum sum is (0, 0) → (1, 0) → (2, 0) → (2, 1) → (2, 2)

Input: mat[][] = {{10, 20, 30}, {40, 50, 40}, {70, 80, 80}}
Output:
10 30 60
50 100 140
120 200 280

Approach: The problem can be solved using Dynamic Programming. Below is the recurrence relation to solve the problem.



Recurrence relation:
pathSum(i, j) = mat[i][j] + max(pathSum(i – 1, j), pathSum(i, j – 1)) 
where i > 0 and j > 0

Base Case:
If i = 0 and j = 0: return mat[0][0]
If i = 0: return mat[i][j] + pathSum(i, j – 1)
If j = 0: return mat[i][j] + pathSum(i – 1, j)

Follow the steps below to solve the problem:

  1. Initialize the matrix dp[][], where dp[i][j] store the maximum path sum from (0, 0) to (i, j).
  2. Use the above mentioned recurrence relation to compute the value of dp[i][j].
  3. Finally, print the value of dp[][] matrix.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
#define SZ 100
 
// Function to get the maximum path
// sum from top-left cell to all
// other cells of the given matrix
void pathSum(const int mat[SZ][SZ],
             int N, int M)
{
 
    // Store the maximum path sum
    int dp[N][M];
 
    // Initialize the value
    // of dp[i][j] to 0.
    memset(dp, 0, sizeof(dp));
 
    // Base case
    dp[0][0] = mat[0][0];
    for (int i = 1; i < N; i++) {
        dp[i][0] = mat[i][0]
                   + dp[i - 1][0];
    }
 
    for (int j = 1; j < M; j++) {
        dp[0][j] = mat[0][j]
                   + dp[0][j - 1];
    }
 
    // Compute the value of dp[i][j]
    // using the recurrence relation
    for (int i = 1; i < N; i++) {
        for (int j = 1; j < M; j++) {
            dp[i][j] = mat[i][j]
                       + max(dp[i - 1][j],
                             dp[i][j - 1]);
        }
    }
 
    // Print maximum path sum from
    // the top-left cell
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
}
 
// Driver Code
int main()
{
    int mat[SZ][SZ]
        = { { 3, 2, 1 },
            { 6, 5, 4 },
            { 7, 8, 9 } };
    int N = 3;
    int M = 3;
 
    pathSum(mat, N, M);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
static final int SZ = 100;
 
// Function to get the maximum path
// sum from top-left cell to all
// other cells of the given matrix
static void pathSum(int [][]mat,
                    int N, int M)
{
  // Store the maximum path sum
  int [][]dp = new int[N][M];
   
  // Base case
  dp[0][0] = mat[0][0];
   
  for (int i = 1; i < N; i++)
  {
    dp[i][0] = mat[i][0] +
               dp[i - 1][0];
  }
 
  for (int j = 1; j < M; j++)
  {
    dp[0][j] = mat[0][j] +
               dp[0][j - 1];
  }
 
  // Compute the value of dp[i][j]
  // using the recurrence relation
  for (int i = 1; i < N; i++)
  {
    for (int j = 1; j < M; j++)
    {
      dp[i][j] = mat[i][j] +
                 Math.max(dp[i - 1][j],
                          dp[i][j - 1]);
    }
  }
 
  // Print maximum path sum from
  // the top-left cell
  for (int i = 0; i < N; i++)
  {
    for (int j = 0; j < M; j++)
    {
      System.out.print(dp[i][j] + " ");
    }
    System.out.println();
  }
}
 
// Driver Code
public static void main(String[] args)
{
  int mat[][] = {{3, 2, 1},
                 {6, 5, 4},
                 {7, 8, 9}};
  int N = 3;
  int M = 3;
  pathSum(mat, N, M);
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 Program to implement
# the above appraoch
 
# Function to get the maximum path
# sum from top-left cell to all
# other cells of the given matrix
def pathSum(mat, N, M):
 
    # Store the maximum path sum
    # Initialize the value
    # of dp[i][j] to 0.
    dp = [[0 for x in range(M)]
             for y in range(N)]
 
    # Base case
    dp[0][0] = mat[0][0]
    for i in range(1, N):
        dp[i][0] = (mat[i][0] +
                    dp[i - 1][0])
 
    for j in range(1, M):
        dp[0][j] = (mat[0][j] +
                    dp[0][j - 1])
 
    # Compute the value of dp[i][j]
    # using the recurrence relation
    for i in range(1, N):
        for j in range(1, M):
            dp[i][j] = (mat[i][j] +
                        max(dp[i - 1][j],
                            dp[i][j - 1]))
 
    # Print maximum path sum
    # from the top-left cell
    for i in range(N):
        for j in range(M):
            print(dp[i][j],
                  end = " ")
        print()
 
# Driver code
if __name__ == '__main__':
 
    mat = [[3, 2, 1],
           [6, 5, 4],
           [7, 8, 9]]
    N = 3
    M = 3
    pathSum(mat, N, M)
 
# This code is contributed by Shivam Singh

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
class GFG{
 
static readonly int SZ = 100;
 
// Function to get the maximum path
// sum from top-left cell to all
// other cells of the given matrix
static void pathSum(int [,]mat,
                    int N, int M)
{
  // Store the maximum path
  // sum
  int [,]dp = new int[N, M];
   
  // Base case
  dp[0, 0] = mat[0, 0];
   
  for (int i = 1; i < N; i++)
  {
    dp[i, 0] = mat[i, 0] +
               dp[i - 1, 0];
  }
 
  for (int j = 1; j < M; j++)
  {
    dp[0, j] = mat[0, j] +
               dp[0, j - 1];
  }
 
  // Compute the value of dp[i,j]
  // using the recurrence relation
  for (int i = 1; i < N; i++)
  {
    for (int j = 1; j < M; j++)
    {
      dp[i, j] = mat[i,j] +
                Math.Max(dp[i - 1, j],
                          dp[i, j - 1]);
    }
  }
 
  // Print maximum path sum from
  // the top-left cell
  for (int i = 0; i < N; i++)
  {
    for (int j = 0; j < M; j++)
    {
      Console.Write(dp[i, j] + " ");
    }
    Console.WriteLine();
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  int [,]mat = {{3, 2, 1},
                {6, 5, 4},
                {7, 8, 9}};
  int N = 3;
  int M = 3;
  pathSum(mat, N, M);
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Output: 

3 5 6 
9 14 18 
16 24 33









 

Time Complexity: O(N * M)
Auxiliary Space: O(N * M)

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
Recommended Articles
Page :