Open In App

# Maximum path sum from top left to bottom right of a matrix passing through one of the given cells

Given a matrix mat[][] of dimensions N * M and a set of coordinates of cell coordinates[][] of size Q, the task is to find the maximum sum of a path from the top-left cell (1, 1) to the bottom-right cell (N, M), such that the path should contain at least one of the coordinates from the array coordinates[][2]. The only moves allowed from any cell (i, j) of the matrix are (i + 1, j) or (i, j + 1).

Examples:

Input: mat[][  = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}, coordinates[][] = {{1, 2}, {2, 2}}
Output: 27
Explanation:
The path having the maximum is given by:
(1, 1) -> (2, 1) -> (2, 2) -> (3, 2) -> (3, 3).
The above path passes through the coordinates (2, 2). Therefore, the sum of the path is given by (1 + 4 + 5 + 8 + 9) = 27, which is maximum path.

Input: mat[][] = {{1, 3}, {6, 7}, {8, 9}} , coordinates[][2] = {{1, 1}}
Output: 24

Naive Approach: The simplest approach to solve the given problem is to generate all possible paths from the top-left to the bottom-right cell of the matrix and print the maximum sum of cells of that path whose at least one of the coordinates in the path lies in the array coordinates[][].

Time Complexity: O((N + M)!)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by using Dynamic Programming. Consider the two matrices start[][] and end[][] such that start[i][j] denotes the maximum path sum from the cell (1, 1) to the cell (i, j) and end[i][j] denotes the maximum path sum from the cell (i, j) to the cell (N, M). Therefore, for any coordinate (X, Y), the maximum path sum can be calculated as:

start[X][Y] + end[X][Y] – mat[X][Y]

Follow the steps below to solve the problem:

• Initialize two matrices, say start[][] and end[][] of dimensions N*M such that start[i][j] denotes the maximum path sum from the cell (1, 1) to the cell (i, j) and end[i][j] denotes the maximum path sum from the cell (i, j) to the cell (N, M).
• Initialize a variable, say ans as INT_MIN that stores the resultant maximum sum.
• Calculate the maximum path sum from the cell (1, 1) to each cell (i, j) using the Bottom-Up Approach discussed in this article and store it in the matrix start[][].
• Calculate the maximum path sum from the cell (N, M) to each cell (i, j) using the Top-Down Approach discussed in this article and store it in the matrix end[][].
• Traverse the array coordinates[][] and for each coordinate (X, Y) update the value of ans as the maximum of ans and (start[X][Y] + end[X][Y] – mat[X][Y]).
• After completing the above steps, print the value of ans as the resultant maximum sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Stores the maximum path sum from the``// cell (1, 1) to (N, M)``int` `start[3][3];` `// Stores the maximum path sum from the``// cell (j, j) to (N, M)``int` `ending[3][3];` `// Function to find the maximum path``// sum from the cell (1, 1) to (N, M)``void` `calculateStart(``int` `n, ``int` `m)``{``    ``// Traverse the first row``    ``for` `(``int` `i = 1; i < m; ++i) {``        ``start[0][i] += start[0][i - 1];``    ``}` `    ``// Traverse the first column``    ``for` `(``int` `i = 1; i < n; ++i) {``        ``start[i][0] += start[i - 1][0];``    ``}` `    ``// Traverse the matrix``    ``for` `(``int` `i = 1; i < n; ++i) {` `        ``for` `(``int` `j = 1; j < m; ++j) {` `            ``// Update the value of``            ``// start[i][j]``            ``start[i][j] += max(start[i - 1][j],``                               ``start[i][j - 1]);``        ``}``    ``}``}` `// Function to find the maximum path``// sum from the cell (j, j) to (N, M)``void` `calculateEnd(``int` `n, ``int` `m)``{``    ``// Traverse the last row``    ``for` `(``int` `i = n - 2; i >= 0; --i) {``        ``ending[i][m - 1] += ending[i + 1][m - 1];``    ``}` `    ``// Traverse the last column``    ``for` `(``int` `i = m - 2; i >= 0; --i) {``        ``ending[n - 1][i] += ending[n - 1][i + 1];``    ``}` `    ``// Traverse the matrix``    ``for` `(``int` `i = n - 2; i >= 0; --i) {` `        ``for` `(``int` `j = m - 2; j >= 0; --j) {` `            ``// Update the value of``            ``// ending[i][j]``            ``ending[i][j] += max(ending[i + 1][j],``                                ``ending[i][j + 1]);``        ``}``    ``}``}` `// Function to find the maximum path sum``// from the top-left to the bottom right``// cell such that path contains one of``// the cells in the array coordinates[][]``void` `maximumPathSum(``int` `mat[][3], ``int` `n,``                    ``int` `m, ``int` `q,``                    ``int` `coordinates[][2])``{``    ``// Initialize the start and the``    ``// end matrices``    ``for` `(``int` `i = 0; i < n; ++i) {``        ``for` `(``int` `j = 0; j < m; ++j) {``            ``start[i][j] = mat[i][j];``            ``ending[i][j] = mat[i][j];``        ``}``    ``}` `    ``// Calculate the start matrix``    ``calculateStart(n, m);` `    ``// Calculate the end matrix``    ``calculateEnd(n, m);` `    ``// Stores the maximum path sum``    ``int` `ans = 0;` `    ``// Traverse the coordinates``    ``for` `(``int` `i = 0; i < q; ++i) {` `        ``int` `X = coordinates[i][0] - 1;``        ``int` `Y = coordinates[i][1] - 1;` `        ``// Update the value of ans``        ``ans = max(ans, start[X][Y]``                           ``+ ending[X][Y]``                           ``- mat[X][Y]);``    ``}` `    ``// Print the resultant maximum``    ``// sum path value``    ``cout << ans;``}` `// Drive Code``int` `main()``{` `    ``int` `mat[][3] = { { 1, 2, 3 },``                     ``{ 4, 5, 6 },``                     ``{ 7, 8, 9 } };``    ``int` `N = 3;``    ``int` `M = 3;``    ``int` `Q = 2;``    ``int` `coordinates[][2] = { { 1, 2 },``                             ``{ 2, 2 } };` `    ``maximumPathSum(mat, N, M, Q,``                   ``coordinates);``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Stores the maximum path sum from the``// cell (1, 1) to (N, M)``static` `int` `start[][] = ``new` `int``[``3``][``3``];` `// Stores the maximum path sum from the``// cell (j, j) to (N, M)``static` `int` `ending[][] = ``new` `int``[``3``][``3``];` `// Function to find the maximum path``// sum from the cell (1, 1) to (N, M)``static` `void` `calculateStart(``int` `n, ``int` `m)``{``    ` `    ``// Traverse the first row``    ``for``(``int` `i = ``1``; i < m; ++i)``    ``{``        ``start[``0``][i] += start[``0``][i - ``1``];``    ``}` `    ``// Traverse the first column``    ``for``(``int` `i = ``1``; i < n; ++i)``    ``{``        ``start[i][``0``] += start[i - ``1``][``0``];``    ``}` `    ``// Traverse the matrix``    ``for``(``int` `i = ``1``; i < n; ++i)``    ``{``        ``for``(``int` `j = ``1``; j < m; ++j)``        ``{``            ` `            ``// Update the value of``            ``// start[i][j]``            ``start[i][j] += Math.max(start[i - ``1``][j],``                                 ``start[i][j - ``1``]);``        ``}``    ``}``}` `// Function to find the maximum path``// sum from the cell (j, j) to (N, M)``static` `void` `calculateEnd(``int` `n, ``int` `m)``{``    ` `    ``// Traverse the last row``    ``for``(``int` `i = n - ``2``; i >= ``0``; --i)``    ``{``        ``ending[i][m - ``1``] += ending[i + ``1``][m - ``1``];``    ``}` `    ``// Traverse the last column``    ``for``(``int` `i = m - ``2``; i >= ``0``; --i)``    ``{``        ``ending[n - ``1``][i] += ending[n - ``1``][i + ``1``];``    ``}` `    ``// Traverse the matrix``    ``for``(``int` `i = n - ``2``; i >= ``0``; --i)``    ``{``        ``for``(``int` `j = m - ``2``; j >= ``0``; --j)``        ``{``            ` `            ``// Update the value of``            ``// ending[i][j]``            ``ending[i][j] += Math.max(ending[i + ``1``][j],``                                  ``ending[i][j + ``1``]);``        ``}``    ``}``}` `// Function to find the maximum path sum``// from the top-left to the bottom right``// cell such that path contains one of``// the cells in the array coordinates[][]``static` `void` `maximumPathSum(``int` `mat[][], ``int` `n,``                           ``int` `m, ``int` `q,``                           ``int` `coordinates[][])``{``    ` `    ``// Initialize the start and the``    ``// end matrices``    ``for``(``int` `i = ``0``; i < n; ++i)``    ``{``        ``for``(``int` `j = ``0``; j < m; ++j)``        ``{``            ``start[i][j] = mat[i][j];``            ``ending[i][j] = mat[i][j];``        ``}``    ``}` `    ``// Calculate the start matrix``    ``calculateStart(n, m);` `    ``// Calculate the end matrix``    ``calculateEnd(n, m);` `    ``// Stores the maximum path sum``    ``int` `ans = ``0``;` `    ``// Traverse the coordinates``    ``for``(``int` `i = ``0``; i < q; ++i)``    ``{``        ``int` `X = coordinates[i][``0``] - ``1``;``        ``int` `Y = coordinates[i][``1``] - ``1``;` `        ``// Update the value of ans``        ``ans = Math.max(ans, start[X][Y] +``                           ``ending[X][Y] -``                           ``mat[X][Y]);``    ``}` `    ``// Print the resultant maximum``    ``// sum path value``    ``System.out.print(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `mat[][] = { { ``1``, ``2``, ``3` `},``                    ``{ ``4``, ``5``, ``6` `},``                    ``{ ``7``, ``8``, ``9` `} };``    ``int` `N = ``3``;``    ``int` `M = ``3``;``    ``int` `Q = ``2``;``    ``int` `coordinates[][] = { { ``1``, ``2` `},``                            ``{ ``2``, ``2` `} };` `    ``maximumPathSum(mat, N, M, Q,``                   ``coordinates);``}   ``}` `// This code is contributed by code_hunt`

## Python3

 `# Python3 program for the above approach` `# Stores the maximum path sum from the``# cell (1, 1) to (N, M)``start ``=` `[[``0` `for` `i ``in` `range``(``3``)]``            ``for` `j ``in` `range``(``3``)]` `# Stores the maximum path sum from the``# cell (j, j) to (N, M)``ending ``=` `[[``0` `for` `i ``in` `range``(``3``)]``             ``for` `j ``in` `range``(``3``)]` `# Function to find the maximum path``# sum from the cell (1, 1) to (N, M)``def` `calculateStart(n, m):``    ` `    ``# Traverse the first row``    ``for` `i ``in` `range``(``1``, m, ``1``):``        ``start[``0``][i] ``+``=` `start[``0``][i ``-` `1``]` `    ``# Traverse the first column``    ``for` `i ``in` `range``(``1``, n, ``1``):``        ``start[i][``0``] ``+``=` `start[i ``-` `1``][``0``]` `    ``# Traverse the matrix``    ``for` `i ``in` `range``(``1``, n, ``1``):``        ``for` `j ``in` `range``(``1``, m, ``1``):``            ` `            ``# Update the value of``            ``# start[i][j]``            ``start[i][j] ``+``=` `max``(start[i ``-` `1``][j],``                               ``start[i][j ``-` `1``])` `# Function to find the maximum path``# sum from the cell (j, j) to (N, M)``def` `calculateEnd(n, m):``    ` `    ``# Traverse the last row``    ``i ``=` `n ``-` `2``    ` `    ``while``(i >``=` `0``):``        ``ending[i][m ``-` `1``] ``+``=` `ending[i ``+` `1``][m ``-` `1``]``        ``i ``-``=` `1` `    ``# Traverse the last column``    ``i ``=` `m ``-` `2``    ` `    ``while``(i >``=` `0``):``        ``ending[n ``-` `1``][i] ``+``=` `ending[n ``-` `1``][i ``+` `1``]``        ``i ``-``=` `1` `    ``# Traverse the matrix``    ``i ``=` `n ``-` `2``    ` `    ``while``(i >``=` `0``):``        ``j ``=` `m ``-` `2``        ``while``(j >``=` `0``):``            ` `            ``# Update the value of``            ``# ending[i][j]``            ``ending[i][j] ``+``=` `max``(ending[i ``+` `1``][j],``                                ``ending[i][j ``+` `1``])``            ``j ``-``=` `1``            ` `        ``i ``-``=` `1` `# Function to find the maximum path sum``# from the top-left to the bottom right``# cell such that path contains one of``# the cells in the array coordinates[][]``def` `maximumPathSum(mat, n, m, q, coordinates):``    ` `    ``# Initialize the start and the``    ``# end matrices``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(m):``            ``start[i][j] ``=` `mat[i][j]``            ``ending[i][j] ``=` `mat[i][j]` `    ``# Calculate the start matrix``    ``calculateStart(n, m)` `    ``# Calculate the end matrix``    ``calculateEnd(n, m)` `    ``# Stores the maximum path sum``    ``ans ``=` `0` `    ``# Traverse the coordinates``    ``for` `i ``in` `range``(q):``        ``X ``=` `coordinates[i][``0``] ``-` `1``        ``Y ``=` `coordinates[i][``1``] ``-` `1` `        ``# Update the value of ans``        ``ans ``=` `max``(ans, start[X][Y] ``+``                      ``ending[X][Y] ``-``                         ``mat[X][Y])` `    ``# Print the resultant maximum``    ``# sum path value``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``mat ``=` `[ [ ``1``, ``2``, ``3` `],``            ``[ ``4``, ``5``, ``6` `],``            ``[ ``7``, ``8``, ``9` `] ]``    ``N ``=` `3``    ``M ``=` `3``    ``Q ``=` `2``    ` `    ``coordinates ``=` `[ [ ``1``, ``2` `], [ ``2``, ``2` `] ]` `    ``maximumPathSum(mat, N, M, Q,coordinates)` `# This code is contributed by ipg2016107`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Stores the maximum path sum from the``// cell (1, 1) to (N, M)``static` `int``[,] start = ``new` `int``[3, 3];` `// Stores the maximum path sum from the``// cell (j, j) to (N, M)``static` `int``[,] ending = ``new` `int``[3, 3];` `// Function to find the maximum path``// sum from the cell (1, 1) to (N, M)``static` `void` `calculateStart(``int` `n, ``int` `m)``{``    ` `    ``// Traverse the first row``    ``for``(``int` `i = 1; i < m; ++i)``    ``{``        ``start[0, i] += start[0, i - 1];``    ``}` `    ``// Traverse the first column``    ``for``(``int` `i = 1; i < n; ++i)``    ``{``        ``start[i, 0] += start[i - 1, 0];``    ``}` `    ``// Traverse the matrix``    ``for``(``int` `i = 1; i < n; ++i)``    ``{``        ``for``(``int` `j = 1; j < m; ++j)``        ``{``            ` `            ``// Update the value of``            ``// start[i][j]``            ``start[i, j] += Math.Max(start[i - 1, j],``                                 ``start[i, j - 1]);``        ``}``    ``}``}` `// Function to find the maximum path``// sum from the cell (j, j) to (N, M)``static` `void` `calculateEnd(``int` `n, ``int` `m)``{``    ` `    ``// Traverse the last row``    ``for``(``int` `i = n - 2; i >= 0; --i)``    ``{``        ``ending[i, m - 1] += ending[i + 1, m - 1];``    ``}` `    ``// Traverse the last column``    ``for``(``int` `i = m - 2; i >= 0; --i)``    ``{``        ``ending[n - 1, i] += ending[n - 1, i + 1];``    ``}` `    ``// Traverse the matrix``    ``for``(``int` `i = n - 2; i >= 0; --i)``    ``{``        ``for``(``int` `j = m - 2; j >= 0; --j)``        ``{``            ` `            ``// Update the value of``            ``// ending[i][j]``            ``ending[i, j] += Math.Max(ending[i + 1, j],``                                  ``ending[i, j + 1]);``        ``}``    ``}``}` `// Function to find the maximum path sum``// from the top-left to the bottom right``// cell such that path contains one of``// the cells in the array coordinates[][]``static` `void` `maximumPathSum(``int``[,] mat, ``int` `n,``                           ``int` `m, ``int` `q,``                           ``int``[,] coordinates)``{``    ` `    ``// Initialize the start and the``    ``// end matrices``    ``for``(``int` `i = 0; i < n; ++i)``    ``{``        ``for``(``int` `j = 0; j < m; ++j)``        ``{``            ``start[i, j] = mat[i, j];``            ``ending[i, j] = mat[i, j];``        ``}``    ``}` `    ``// Calculate the start matrix``    ``calculateStart(n, m);` `    ``// Calculate the end matrix``    ``calculateEnd(n, m);` `    ``// Stores the maximum path sum``    ``int` `ans = 0;` `    ``// Traverse the coordinates``    ``for``(``int` `i = 0; i < q; ++i)``    ``{``        ``int` `X = coordinates[i, 0] - 1;``        ``int` `Y = coordinates[i, 1] - 1;` `        ``// Update the value of ans``        ``ans = Math.Max(ans, start[X, Y] +``                           ``ending[X, Y] -``                           ``mat[X, Y]);``    ``}` `    ``// Print the resultant maximum``    ``// sum path value``    ``Console.Write(ans);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[,] mat = { { 1, 2, 3 },``                    ``{ 4, 5, 6 },``                    ``{ 7, 8, 9 } };``    ``int` `N = 3;``    ``int` `M = 3;``    ``int` `Q = 2;``    ``int``[,] coordinates = { { 1, 2 },``                            ``{ 2, 2 } };` `    ``maximumPathSum(mat, N, M, Q,``                   ``coordinates);``}``}` `// This code is contributed by target_2.`

## Javascript

 ``

Output:

`27`

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