304 North Cardinal St.
Dorchester Center, MA 02124

# Longest Increasing Path in a Matrix LeetCode Solution

## Problem – Longest Increasing Path in a Matrix

Given an `m x n` integers `matrix`, return the length of the longest increasing path in `matrix`.

From each cell, you can either move in four directions: left, right, up, or down. You may not move diagonally or move outside the boundary (i.e., wrap-around is not allowed).

Example 1:

``````Input: matrix = [[9,9,4],[6,6,8],[2,1,1]]
Output: 4
Explanation: The longest increasing path is [1, 2, 6, 9].``````

Example 2:

``````Input: matrix = [[3,4,5],[3,2,6],[2,2,1]]
Output: 4
Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.``````

Example 3:

``````Input: matrix = [[1]]
Output: 1``````

Constraints:

• `m == matrix.length`
• `n == matrix[i].length`
• `1 <= m, n <= 200`
• `0 <= matrix[i][j] <= 231 - 1`

### Longest Increasing Path in a Matrix LeetCode Solution in Java

``````public static final int[][] dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

public int longestIncreasingPath(int[][] matrix) {
if(matrix.length == 0) return 0;
int m = matrix.length, n = matrix[0].length;
int[][] cache = new int[m][n];
int max = 1;
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
int len = dfs(matrix, i, j, m, n, cache);
max = Math.max(max, len);
}
}
return max;
}

public int dfs(int[][] matrix, int i, int j, int m, int n, int[][] cache) {
if(cache[i][j] != 0) return cache[i][j];
int max = 1;
for(int[] dir: dirs) {
int x = i + dir[0], y = j + dir[1];
if(x < 0 || x >= m || y < 0 || y >= n || matrix[x][y] <= matrix[i][j]) continue;
int len = 1 + dfs(matrix, x, y, m, n, cache);
max = Math.max(max, len);
}
cache[i][j] = max;
return max;
}
``````

### Longest Increasing Path in a Matrix LeetCode Solution in Python

``````def longestIncreasingPath(self, matrix):
def dfs(i, j):
if not dp[i][j]:
val = matrix[i][j]
dp[i][j] = 1 + max(
dfs(i - 1, j) if i and val > matrix[i - 1][j] else 0,
dfs(i + 1, j) if i < M - 1 and val > matrix[i + 1][j] else 0,
dfs(i, j - 1) if j and val > matrix[i][j - 1] else 0,
dfs(i, j + 1) if j < N - 1 and val > matrix[i][j + 1] else 0)
return dp[i][j]

if not matrix or not matrix[0]: return 0
M, N = len(matrix), len(matrix[0])
dp = [[0] * N for i in range(M)]
return max(dfs(x, y) for x in range(M) for y in range(N))``````

### Longest Increasing Path in a Matrix LeetCode Solution in C++

``````int moves[4][2] = { {-1,0},{1,0},{0,-1},{0,1} };   // all the moves available to us - top, down, left, right
int longestIncreasingPath(vector<vector<int>>& matrix) {
int maxPath = 1; // atleast one cell can always be selected in the path
// explore each cell of matrix to find longest path achievable from that cell and finally return the maximum
for(int i = 0; i < size(matrix); i++)
for(int j = 0; j < size(matrix[0]); j++)
maxPath = max(maxPath, solve(matrix, i, j));
return maxPath;
}
// recursive solver for each cell
int solve(vector<vector<int>>& mat, int i, int j){
int MAX = 1;  // max length of path starting from cell i,j of matrix
// choosing all the 4 moves available for current cell
for(int k = 0; k < 4; k++){
int new_i = i + moves[k][0], new_j = j + moves[k][1];
// bound checking as well as move to next cell only when it is greater in value
if(new_i < 0 || new_j < 0 || new_i >= size(mat) || new_j >= size(mat[0]) || mat[new_i][new_j] <= mat[i][j]) continue;
// MAX will be updated each time to store maximum of path length from each move
MAX = max(MAX, 1 + solve(mat, new_i, new_j));
}
return MAX;
}
``````
##### Longest Increasing Path in a Matrix LeetCode Solution Review:

In our experience, we suggest you solve this Longest Increasing Path in a Matrix LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Longest Increasing Path in a Matrix LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Longest Increasing Path in a Matrix LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions