# Maximize path sum from top-left cell to all other cells of a given Matrix

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++ program to implement` `// the above approach` `#include ` `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);` `}`

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

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

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

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : SHIVAMSINGH67, 29AjayKumar

Article Tags :