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}} Explanation: Path followed is 500 -> 1000 -> 300 -> 1000 -> 200
Naive Approach: Recursion
Going through the Naive approach by traversing every possible path. But, this is costly. So, use Dynamic Programming here in order to reduce the time complexity.
#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];
// 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 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 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 program for // Recursive implementation of // Max sum path import java.io.*;
class GFG {
// Function for finding maximum sum
public static int maxPathSum( int matrix[][], int i, int j)
{
if (i< 0 || j< 0 ) {
return -100_000_000;
}
if (i== 0 && j== 0 ) {
return matrix[i][j];
}
int up = matrix[i][j] + maxPathSum(matrix, i - 1 , j);
int right = matrix[i][j] + maxPathSum(matrix, i, j - 1 );
int up_left_diagonal = matrix[i][j] + maxPathSum(matrix, i - 1 , j - 1 );
return Math.max(up , Math.max( right, up_left_diagonal));
}
/* Driver program to test above functions */
public static void main(String[] args)
{
int matrix [][] ={{ 100 , - 350 , - 200 }, {- 100 , - 300 , 700 }};
System.out.print(maxPathSum(matrix, 1 , 2 ));
}
} // This code is contributed by Rohini Chandra |
# No of rows and columns n = 0
m = 0
# Declaring the matrix of maximum # 100 rows and 100 columns rows, cols = ( 100 , 100 )
a = [[ 0 for i in range (cols)] for j in range (rows)]
# 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, a
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 n, m, a, total_sum, current_sum
# Checking boundary condition
if i = = n - 1 and j = = m - 1 :
return a[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 )):
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
return total_sum
# Driver program if __name__ = = "__main__" :
inputMatrix()
# Calling the implemented function
maximum_sum = maximum_sum_path( 0 , 0 )
print (maximum_sum)
|
using System;
using System.Collections.Generic;
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];
// 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 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);
// Returning the updated maximum value
return total_sum;
}
// Driver Code
static void Main( string [] args)
{
inputMatrix();
// Calling the implemented function
int maximum_sum = maximum_sum_path(0, 0);
Console.Write(maximum_sum);
}
} |
<script> const 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);
for (let i=0;i<N;i++){
a[i] = new Array(N);
} // 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 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);
// Returning the updated maximum value
return total_sum;
} // Driver Code inputMatrix(); // Calling the implemented function let maximum_sum = maximum_sum_path(0, 0); document.write(maximum_sum, "</br>" );
// This code is contributed by shinjanpatra </script> |
3000
Time Complexity: O(2N*M)
Auxiliary Space: O(N*M)
2. Efficient Approach(Memoization) : Dynamic programming is used to solve the above problem in a recursive way.
- Allot a position at the beginning of the matrix at (0, 0).
- Check each next allowed position from the current position and select the path with maximum sum.
- 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.
- 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.
- Update the maximum of all possible paths returned by each recursive calls made.
- Go till the position reaches the destination cell, i.e, (n-1.m-1).
Below is the implementation of the above approach:
#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;
} |
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 |
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)
|
// 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 |
<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> |
3000
Time Complexity: O(N*M)
Auxiliary Space: O(N*M) + O(N+M) -> O(NxM) is for the declared matrix of size nxm and O(N+M) is for the stack space (maximum recursive recursion calls).
3. Tabulation approach: This approach will remove the extra space complexity i.e O(N+M) caused by recursion in the above approach.
- Declare an array of size NxM – dp[N][M].
- Traverse through the created array row-wise and start filling the values in it.
- First row of the `dp` array i.e. index (0,j) ,where j represents column, will contain the values same as the first row of the given `matrix` array.
- Otherwise, we will calculate the values for up (i-1,j), right (i,j-1) and up_left_diagonal (i-1,j-1) for the current cell and the maximum value of them will be the value for the current cell ie dp[i][j].
- Finally, the maximum path sum of the matrix will be at dp[n-1][m-1] where n=no. of rows and m=no. of columns.
// C++ program for // Recursive implementation of // Max sum path #include <bits/stdc++.h> using namespace std;
int maxPathSum( int matrix[2][3], int i, int j)
{ if (i < 0 || j < 0) {
return -1000000000;
}
if (i == 0 && j == 0) {
return matrix[i][j];
}
int up = matrix[i][j] + maxPathSum(matrix, i - 1, j);
int right = matrix[i][j] + maxPathSum(matrix, i, j - 1);
int up_left_diagonal
= matrix[i][j] + maxPathSum(matrix, i - 1, j - 1);
return max(up, max(right, up_left_diagonal));
} int main()
{ int matrix[2][3]
= { { 100, -350, -200 }, { -100, -300, 700 } };
cout << maxPathSum(matrix, 1, 2) << endl;
return 0;
} // // This code is contributed by lokeshpotta20. |
// Java program for // Recursive implementation of // Max sum path import java.io.*;
class GFG {
/* Driver program to test above functions */
public static void main(String[] args)
{
int matrix [][] = {{ 100 , - 350 , - 200 }, {- 100 , - 300 , 700 }};
int n = matrix.length;
int m = matrix[ 0 ].length;
int dp[][] = new int [n][m], up, right, up_left_diagonal;
for ( int i= 0 ; i<n; i++){
for ( int j= 0 ; j<m; j++){
if (i== 0 ) {
dp[i][j] = matrix[i][j];
}
else {
up = matrix[i][j];
if (i> 0 ) up += dp[i- 1 ][j];
else up -= ( int )Math.pow( 10 , 9 );
right = matrix[i][j];
if (j> 0 ) right += dp[i][j- 1 ];
else right -= ( int )Math.pow( 10 , 9 );
up_left_diagonal = matrix[i][j];
if (i> 0 && j> 0 ) up_left_diagonal += dp[i- 1 ][j- 1 ];
else up_left_diagonal -= ( int )Math.pow( 10 , 9 );
dp[i][j] = Math.max(up , Math.max( right, up_left_diagonal));
}
}
}
System.out.println(dp[n- 1 ][m- 1 ]);
}
} // This code is contributed by Rohini Chandra |
# Python program for Recursive implementation of Max sum path # Function for finding maximum sum def maxPathSum(matrix, i, j):
if i < 0 or j < 0 :
return - 1000000000
if i = = 0 and j = = 0 :
return matrix[i][j]
up = matrix[i][j] + maxPathSum(matrix, i - 1 , j)
right = matrix[i][j] + maxPathSum(matrix, i, j - 1 )
up_left_diagonal = matrix[i][j] + maxPathSum(matrix, i - 1 , j - 1 )
return max (up, max (right, up_left_diagonal))
matrix = [[ 100 , - 350 , - 200 ], [ - 100 , - 300 , 700 ]]
print (maxPathSum(matrix, 1 , 2 ))
# This code is contributed by sankar |
// C# program for // Recursive implementation of // Max sum path using System;
class GFG
{ // Function for finding maximum sum
public static int maxPathSum( int [,] matrix, int i, int j)
{
if (i<0 || j<0) {
return -1000000000;
}
if (i==0 && j==0) {
return matrix[i,j];
}
int up = matrix[i,j] + maxPathSum(matrix, i - 1, j);
int right = matrix[i,j] + maxPathSum(matrix, i, j - 1);
int up_left_diagonal = matrix[i,j] + maxPathSum(matrix, i - 1, j - 1);
return Math.Max(up , Math.Max( right, up_left_diagonal));
}
/* Driver program to test above functions */
public static void Main( string [] args)
{
int [,] matrix = {{100, -350, -200}, {-100, -300, 700}};
Console.Write(maxPathSum(matrix, 1, 2));
}
} |
// JavaScript program for // Recursive implementation of // Max sum path function maxPathSum(matrix, i, j) {
if (i < 0 || j < 0) {
return -1000000000;
} if (i === 0 && j === 0) {
return matrix[i][j];
} const up = matrix[i][j] + maxPathSum(matrix, i - 1, j); const right = matrix[i][j] + maxPathSum(matrix, i, j - 1); const up_left_diagonal = matrix[i][j] + maxPathSum(matrix, i - 1, j - 1); return Math.max(up, Math.max(right, up_left_diagonal));
} // Driver code const matrix = [[100, -350, -200], [-100, -300, 700]]; console.log(maxPathSum(matrix, 1, 2)); |
500
Time complexity: O(NxM)
Auxiliary Space: O(NxM)