Codestin Search App

Longest Increasing Path in a Matrix - Problem

Array Dynamic Programming Depth-First Search Breadth-First Search Graph Topological Sort Memoization Matrix Hard

Given an m × n matrix of integers, find the length of the longest strictly increasing path. You can move in four directions (up, down, left, right) but cannot move diagonally or outside the matrix boundaries.

Think of it like hiking through a terrain where each cell represents an elevation. You want to find the longest uphill path where each step takes you to a higher elevation than the previous one.

Example: In matrix [[9,9,4],[6,6,8],[2,1,1]], one longest increasing path could be 1 → 2 → 6 → 9 with length 4.

Input & Output

example_1.py — Basic Matrix

$ Input: matrix = [[9,9,4],[6,6,8],[2,1,1]]

› Output: 4

💡 Note: The longest increasing path is [1,2,6,9] with length 4. Starting from bottom-left (1), we can go up to 2, then up to 6, then right to 9.

example_2.py — Complex Path

$ Input: matrix = [[3,4,5],[3,2,6],[2,2,1]]

› Output: 4

💡 Note: The longest increasing path is [2,3,4,5] or [2,3,4,6] both with length 4. Multiple paths can have the same maximum length.

example_3.py — Single Element

$ Input: matrix = [[1]]

› Output: 1

💡 Note: With only one element, the longest increasing path has length 1 (the element itself).

Visualization

Tap to expand

Understanding the Visualization

Survey the terrain

Look at the elevation map (matrix) and identify all possible starting points

Use smart exploration

From each point, explore all uphill directions but remember the best path from each visited location

Cache your findings

Once you find the longest uphill path from a location, mark it on your map so you don't need to re-explore

Find the maximum

Compare all starting points and return the longest trail length found

Key Takeaway

🎯 Key Insight: Memoization transforms this from an exponential search problem into a linear one by ensuring each location is fully explored exactly once.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each cell is visited exactly once due to memoization, and each visit takes O(1) amortized time

✓ Linear Growth

Space Complexity

O(m×n)

Memoization table stores result for each cell, plus recursion stack depth up to m×n

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 200
-2³¹ ≤ matrix[i][j] ≤ 2³¹ - 1
Note: Matrix values can be negative

Asked in

G Google 85 a Amazon 72 ⊞ Microsoft 68 f Meta 45

The optimal solution uses DFS with memoization to achieve O(m×n) time complexity. By caching the longest increasing path from each cell, we avoid recalculating the same subproblems. The key insight is that once we know the longest path from a cell, we never need to recalculate it - this transforms an exponential problem into a linear one.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS from Every Cell	O(2^(m×n))	O(m×n)	Try DFS from every cell without memoization - extremely inefficient
DFS with Memoization (Optimal)	O(m×n)	O(m×n)	Use DFS with memoization to cache results and avoid recalculating same subproblems

Brute Force DFS from Every Cell — Algorithm Steps

Iterate through every cell in the matrix
For each cell, start a DFS to find the longest increasing path
In DFS, explore all 4 directions if the next cell has a larger value
Return the maximum length found among all starting positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from every cell

Begin DFS from each cell in the matrix

Explore all directions

From each cell, try moving in all 4 directions

Recurse on valid moves

If next cell has larger value, recurse and find max path

Return maximum

Keep track of the longest path found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

int dfs(int** matrix, int x, int y, int m, int n) {
    int maxLength = 1;
    for (int i = 0; i < 4; i++) {
        int nx = x + directions[i][0];
        int ny = y + directions[i][1];
        if (nx >= 0 && nx < m && ny >= 0 && ny < n && matrix[nx][ny] > matrix[x][y]) {
            int length = 1 + dfs(matrix, nx, ny, m, n);
            if (length > maxLength) {
                maxLength = length;
            }
        }
    }
    return maxLength;
}

int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return 0;
    }
    
    int m = matrixSize, n = matrixColSize[0];
    int result = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int length = dfs(matrix, i, j, m, n);
            if (length > result) {
                result = length;
            }
        }
    }
    
    return result;
}

int main() {
    int matrix[3][3] = {{9,9,4},{6,6,8},{2,1,1}};
    int* rows[3];
    for (int i = 0; i < 3; i++) {
        rows[i] = matrix[i];
    }
    int colSizes[3] = {3, 3, 3};
    printf("%d\n", longestIncreasingPath(rows, 3, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m×n))

In worst case, we explore all possible paths from every cell, leading to exponential branching

✓ Linear Growth

Space Complexity

O(m×n)

Recursion stack depth can go up to m×n in worst case

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 200
-2³¹ ≤ matrix[i][j] ≤ 2³¹ - 1
Note: Matrix values can be negative

87.5K Views

High Frequency

~25 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force DFS from Every Cell — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler