Longest Increasing Path in Matrix

• Difficulty Level : Medium
• Last Updated : 19 Jul, 2022

Given a matrix of N rows and M columns. From m[i][j], we can move to m[i+1][j], if m[i+1][j] > m[i][j], or can move to m[i][j+1] if m[i][j+1] > m[i][j]. The task is print longest path length if we start from (0, 0).

Examples:

```Input : N = 4, M = 4
m[][] = { { 1, 2, 3, 4 },
{ 2, 2, 3, 4 },
{ 3, 2, 3, 4 },
{ 4, 5, 6, 7 } };
Output : 7
Longest path is 1 2 3 4 5 6 7.

Input : N = 2, M =2
m[][] = { { 1, 2 },
{ 3, 4 } };
Output :3
Longest path is either 1 2 4 or
1 3 4.```

The idea is to use dynamic programming. Maintain the 2D matrix, dp[][], where dp[i][j] store the value of the length of the longest increasing sequence for submatrix starting from the ith row and jth column.

Let the longest increasing sub sequence values for m[i+1][j] and m[i][j+1] be known already as v1 and v2 respectively. Then the value for m[i][j] will be max(v1, v2) + 1.
We can start from m[n-1][m-1] as the base case with the length of longest increasing subsequence be 1, moving upwards and leftwards updating the value of cells. Then the LIP value for cell m[0][0] will be the answer.

Below is the implementation of this approach:

C++

 `// CPP program to find longest increasing``// path in a matrix.``#include ``#define MAX 10``using` `namespace` `std;` `// Return the length of LIP in 2D matrix``int` `LIP(``int` `dp[][MAX], ``int` `mat[][MAX], ``int` `n, ``int` `m, ``int` `x, ``int` `y)``{``    ``// If value not calculated yet.``    ``if` `(dp[x][y] < 0) {``        ``int` `result = 0;` `        ``// If reach bottom right cell, return 1.``        ``if` `(x == n - 1 && y == m - 1)``            ``return` `dp[x][y] = 1;` `        ``// If reach the corner of the matrix.``        ``if` `(x == n - 1 || y == m - 1)``            ``result = 1;` `        ``// If value greater than below cell.``        ``if``(x != n-1) ``// x reaches last row``         ``if` `(mat[x][y] < mat[x + 1][y])``             ``result = 1 + LIP(dp, mat, n, m, x + 1, y);` `        ``// If value greater than left cell.``        ``if``(y != m-1) ``// y reaches last column``         ``if` `(mat[x][y] < mat[x][y + 1])``             ``result = max(result, 1 + LIP(dp, mat, n, m, x, y + 1));` `        ``dp[x][y] = result;``    ``}` `    ``return` `dp[x][y];``}` `// Wrapper function``int` `wrapper(``int` `mat[][MAX], ``int` `n, ``int` `m)``{``    ``int` `dp[MAX][MAX];``    ``memset``(dp, -1, ``sizeof` `dp);` `    ``return` `LIP(dp, mat, n, m, 0, 0);``}` `// Driven Program``int` `main()``{``    ``int` `mat[][MAX] = {``        ``{ 1, 2, 3, 4 },``        ``{ 2, 2, 3, 4 },``        ``{ 3, 2, 3, 4 },``        ``{ 4, 5, 6, 7 },``    ``};``    ``int` `n = 4, m = 4;``    ``cout << wrapper(mat, n, m) << endl;` `    ``return` `0;``}`

Java

 `// Java program to find longest increasing``// path in a matrix.``import` `java.util.*;` `class` `GFG {` `    ``// Return the length of LIP in 2D matrix``    ``static` `int` `LIP(``int` `dp[][], ``int` `mat[][], ``int` `n,``                   ``int` `m, ``int` `x, ``int` `y)``    ``{``        ``// If value not calculated yet.``        ``if` `(dp[x][y] < ``0``) {``            ``int` `result = ``0``;` `             ``// If reach bottom right cell, return 1.``            ``if` `(x == n - ``1` `&& y == m - ``1``)``                ``return` `dp[x][y] = ``1``;` `            ``// If reach the corner of the matrix.``            ``if` `(x == n - ``1` `|| y == m - ``1``)``                ``result = ``1``;` `            ``// If value greater than below cell.``            ``if` `(x + ``1` `< n && mat[x][y] < mat[x + ``1``][y])``                ``result = ``1` `+ LIP(dp, mat, n, m, x + ``1``, y);` `            ``// If value greater than left cell.``            ``if` `(y + ``1` `< m && mat[x][y] < mat[x][y + ``1``])``                ``result = Math.max(result, ``1` `+ LIP(dp, mat, n, m, x, y + ``1``));` `            ``dp[x][y] = result;``        ``}` `        ``return` `dp[x][y];``    ``}` `    ``// Wrapper function``    ``static` `int` `wrapper(``int` `mat[][], ``int` `n, ``int` `m)``    ``{``        ``int` `dp[][] = ``new` `int``[``10``][``10``];``        ``for` `(``int` `i = ``0``; i < ``10``; i++)``            ``Arrays.fill(dp[i], -``1``);` `        ``return` `LIP(dp, mat, n, m, ``0``, ``0``);``    ``}` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `mat[][] = {``            ``{ ``1``, ``2``, ``3``, ``4` `},``            ``{ ``2``, ``2``, ``3``, ``4` `},``            ``{ ``3``, ``2``, ``3``, ``4` `},``            ``{ ``4``, ``5``, ``6``, ``7` `},``        ``};``        ``int` `n = ``4``, m = ``4``;``        ``System.out.println(wrapper(mat, n, m));``    ``}``}` `// This code is contributed by Arnav Kr. Mandal.`

Python3

 `# Python3 program to find longest``# increasing path in a matrix.``MAX` `=` `20` `# Return the length of``# LIP in 2D matrix``def` `LIP(dp, mat, n, m, x, y):``    ` `    ``# If value not calculated yet.``    ``if` `(dp[x][y] < ``0``):``        ``result ``=` `0``        ` `        ``#  // If reach bottom right cell, return 1``        ``if` `(x ``=``=` `n ``-` `1` `and` `y ``=``=` `m ``-` `1``):``            ``dp[x][y] ``=` `1``            ``return` `dp[x][y]` `        ``# If reach the corner``        ``# of the matrix.``        ``if` `(x ``=``=` `n ``-` `1` `or` `y ``=``=` `m ``-` `1``):``            ``result ``=` `1` `        ``# If value greater than below cell.``        ``if` `(x ``+` `1` `< n ``and` `mat[x][y] < mat[x ``+` `1``][y]):``            ``result ``=` `1` `+` `LIP(dp, mat, n,``                            ``m, x ``+` `1``, y)` `        ``# If value greater than left cell.``        ``if` `(y ``+` `1` `< m ``and` `mat[x][y] < mat[x][y ``+` `1``]):``            ``result ``=` `max``(result, ``1` `+` `LIP(dp, mat, n,``                                        ``m, x, y ``+` `1``))``        ``dp[x][y] ``=` `result``    ``return` `dp[x][y]` `# Wrapper function``def` `wrapper(mat, n, m):``    ``dp ``=` `[[``-``1` `for` `i ``in` `range``(``MAX``)]``            ``for` `i ``in` `range``(``MAX``)]``    ``return` `LIP(dp, mat, n, m, ``0``, ``0``)` `# Driver Code``mat ``=` `[[``1``, ``2``, ``3``, ``4` `],``    ``[``2``, ``2``, ``3``, ``4` `],``    ``[``3``, ``2``, ``3``, ``4` `],``    ``[``4``, ``5``, ``6``, ``7` `]]``n ``=` `4``m ``=` `4``print``(wrapper(mat, n, m))` `# This code is contributed``# by Sahil Shelangia`

C#

 `// C# program to find longest increasing``// path in a matrix.``using` `System;` `public` `class` `GFG {` `    ``// Return the length of LIP in 2D matrix``    ``static` `int` `LIP(``int``[, ] dp, ``int``[, ] mat, ``int` `n,``                   ``int` `m, ``int` `x, ``int` `y)``    ``{``        ``// If value not calculated yet.``        ``if` `(dp[x, y] < 0) {``            ``int` `result = 0;` `            ``// If reach bottom right cell, return 1.``            ``if` `(x == n - 1 && y == m - 1)``                ``return` `dp[x, y] = 1;` `            ``// If reach the corner of the matrix.``            ``if` `(x == n - 1 || y == m - 1)``                ``result = 1;` `            ``// If value greater than below cell.``            ``if` `(x + 1 < n && mat[x, y] < mat[x + 1, y])``                ``result = 1 + LIP(dp, mat, n, m, x + 1, y);` `            ``// If value greater than left cell.``            ``if` `(y + 1 < m && mat[x, y] < mat[x, y + 1])``                ``result = Math.Max(result, 1 + LIP(dp, mat, n, m, x, y + 1));` `            ``dp[x, y] = result;``        ``}` `        ``return` `dp[x, y];``    ``}` `    ``// Wrapper function``    ``static` `int` `wrapper(``int``[, ] mat, ``int` `n, ``int` `m)``    ``{``        ``int``[, ] dp = ``new` `int``[10, 10];``        ``for` `(``int` `i = 0; i < 10; i++) {``            ``for` `(``int` `j = 0; j < 10; j++) {``                ``dp[i, j] = -1;``            ``}``        ``}` `        ``return` `LIP(dp, mat, n, m, 0, 0);``    ``}` `    ``/* Driver code */``    ``public` `static` `void` `Main()``    ``{``        ``int``[, ] mat = {``            ``{ 1, 2, 3, 4 },``            ``{ 2, 2, 3, 4 },``            ``{ 3, 2, 3, 4 },``            ``{ 4, 5, 6, 7 },``        ``};``        ``int` `n = 4, m = 4;``        ``Console.WriteLine(wrapper(mat, n, m));``    ``}``}` `/* This code contributed by PrinciRaj1992 */`

Javascript

 ``

Output

```7
```

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

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up