Longest Increasing Path in a Matrix - Practice Coding Problems

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).

Constraints

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

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.

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
✓ 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	O(2^(m×n))	O(m×n)	Try DFS from every cell without memoization - extremely inefficient

DFS with Memoization (Optimal) — Algorithm Steps

Create a memoization table to cache results for each cell
For each unvisited cell, perform DFS with memoization
In DFS, check if result is already cached - if yes, return it
Otherwise, explore all 4 directions and recursively find the longest path
Cache and return the result for current cell

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize memo table

Create a table to cache results for each cell

DFS with caching

If result exists in memo, return it immediately

Calculate and cache

Otherwise, calculate result and store in memo

Reuse cached results

Future calls to same cell return cached value

Code -

solution.c — C

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

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

int dfs(int** matrix, int x, int y, int m, int n) {
    if (memo[x][y] != 0) {
        return memo[x][y];
    }
    
    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;
            }
        }
    }
    
    memo[x][y] = maxLength;
    return maxLength;
}

int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return 0;
    }
    
    int m = matrixSize, n = matrixColSize[0];
    
    // Initialize memo table
    memo = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        memo[i] = (int*)calloc(n, sizeof(int));
    }
    
    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;
            }
        }
    }
    
    // Free memo table
    for (int i = 0; i < m; i++) {
        free(memo[i]);
    }
    free(memo);
    
    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(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

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

Constraints

Visualization

Related Problems

Common Approaches

DFS with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler