Longest Increasing Path in a Matrix

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 x n matrix of integers, return the length of the longest increasing path in the matrix.

From each cell, you can move in four directions: left, right, up, or down. You cannot move diagonally or outside the boundary.

Input & Output

Example 1 — Basic 3x3 Matrix

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

› Output: 4

💡 Note: The longest increasing path is 1→6→8→9 with length 4. We can start from (2,1) with value 1, move to (1,0) with value 6, then to (1,2) with value 8, then to (0,0) or (0,1) with value 9.

Example 2 — Simple 2x2 Matrix

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

› Output: 3

💡 Note: The longest increasing path is 2→3→4 with length 3. Start from (1,1) with value 2, move to (0,0) with value 3, then to (0,1) with value 4.

Example 3 — Single Cell

$ Input: matrix = [[1]]

› Output: 1

💡 Note: Only one cell exists, so the longest path has length 1.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 200
0 ≤ matrix[i][j] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use memoization to avoid recalculating the longest path from the same cell multiple times. The optimal approach uses DFS with memoization, achieving O(m×n) time and O(m×n) space complexity.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force DFS

⏱️ Time: O(2^(m×n)) Space: O(m×n)

For each cell, recursively explore all four directions and find the longest increasing path. This approach recalculates the same subproblems multiple times.

DFS with Memoization

⏱️ Time: O(m×n) Space: O(m×n)

Use a 2D cache array to store the longest path from each cell. When we revisit a cell, return the cached result instead of recalculating.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int count = 0;
    
    // Try each position that has value 0
    for (int start = 0; start < n; start++) {
        if (nums[start] != 0) continue;
        
        // Try both directions: left (-1) and right (1)
        int directions[2] = {-1, 1};
        for (int d = 0; d < 2; d++) {
            int direction = directions[d];
            
            // Make a copy to simulate
            int* temp = (int*)malloc(n * sizeof(int));
            memcpy(temp, nums, n * sizeof(int));
            
            int curr = start;
            int currDir = direction;
            
            // Use a more generous step limit
            int sum = 0;
            for (int i = 0; i < n; i++) sum += temp[i];
            int maxSteps = sum * n + n * 100;
            int steps = 0;
            
            while (steps < maxSteps) {
                steps++;
                
                // Check bounds - if out of bounds, simulation ends
                if (curr < 0 || curr >= n) break;
                
                // If current position is 0, just move
                if (temp[curr] == 0) {
                    curr += currDir;
                } else {
                    // Decrement, reverse direction, then move
                    temp[curr]--;
                    currDir = -currDir;
                    curr += currDir;
                }
            }
            
            // Check if all elements are 0
            bool allZero = true;
            for (int i = 0; i < n; i++) {
                if (temp[i] != 0) {
                    allZero = false;
                    break;
                }
            }
            
            if (allZero) count++;
            free(temp);
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array format [1,2,3]
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.4K Views

Medium Frequency

~25 min Avg. Time

2.2K 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