# Maximum sum path in a Matrix

• Difficulty Level : Hard
• Last Updated : 02 Mar, 2023

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.

## C++

 `#include ``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

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

## Python3

 `# 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)`

## C#

 `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);``  ``}``}`

## Javascript

 ``

Output

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

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

## 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)`

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

 ``

Output

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

1. Declare an array of size NxM – dp[N][M].
2. Traverse through the created array row-wise and start filling the values in it.
3. 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.
4. 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].
5. 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++

 `// C++ program for``// Recursive implementation of``// Max sum path``#include ``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

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

## Python3

 `# 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#

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

 `// 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));`

Output

`500`

Time complexity: O(NxM)

Auxiliary Space: O(NxM)

My Personal Notes arrow_drop_up