Length of the Longest Increasing Path - Practice Coding Problems

Length of the Longest Increasing Path - Problem

You're navigating through a 2D coordinate system where you need to find the longest possible increasing path that passes through a specific point!

Given an array of coordinates representing points in a 2D plane and an index k, your mission is to find the maximum length of an increasing path that contains the point at coordinates[k].

An increasing path is a sequence of points (x₁, y₁) → (x₂, y₂) → ... → (xₘ, yₘ) where:

Both x and y coordinates strictly increase: xᵢ < xᵢ₊₁ and yᵢ < yᵢ₊₁
All points must exist in the given coordinates array
The path must include coordinates[k]

Example: If coordinates = [[1,2], [2,3], [3,1], [0,1]] and k = 1, the point (2,3) must be included in your longest increasing path.

Input & Output

example_1.py — Basic Path

$ Input: coordinates = [[1,2], [2,3], [3,1], [0,1]], k = 1

› Output: 2

💡 Note: Point k is (2,3). The longest increasing path containing (2,3) has length 2: either [(1,2), (2,3)] or [(2,3), (any point with x>2 and y>3 if exists)]. Since no point satisfies x>2 and y>3, the longest path is [(1,2), (2,3)].

example_2.py — Longer Path

$ Input: coordinates = [[1,1], [2,2], [3,3], [4,4]], k = 1

› Output: 4

💡 Note: Point k is (2,2). The longest increasing path is [(1,1), (2,2), (3,3), (4,4)] which contains (2,2) and has length 4.

example_3.py — Single Point

$ Input: coordinates = [[5,10]], k = 0

› Output: 1

💡 Note: Only one point exists, so the longest path containing coordinates[0] = (5,10) has length 1.

Constraints

1 ≤ n ≤ 1000
0 ≤ k < n
coordinates[i].length == 2
-10⁵ ≤ coordinates[i][0], coordinates[i][1] ≤ 10⁵
All coordinates are distinct

Visualization

Tap to expand

Understanding the Visualization

Organize the Peaks

Sort all mountain peaks by their coordinates to process them systematically

Calculate Ascent Routes

For each peak, find the longest climbing route that ends at that peak

Calculate Descent Routes

For each peak, find the longest climbing route that starts from that peak

Find Optimal Path Through Checkpoint

Combine the best ascent to checkpoint k with the best route from checkpoint k

Key Takeaway

🎯 Key Insight: The longest path through any point equals the longest path ending at that point plus the longest path starting from that point, minus 1 (to avoid double-counting the point itself).

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses dynamic programming with sorting. First, sort coordinates by x then y values. Then compute dpEnd[i] (longest increasing path ending at point i) and dpStart[i] (longest increasing path starting from point i). The answer is dpEnd[k] + dpStart[k] - 1 in the sorted array.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Sorting	O(n²)	O(n)	Sort coordinates and use DP to find longest increasing paths ending/starting at each point
Brute Force (Try All Paths)	O(2^n)	O(n)	Recursively explore all possible increasing paths that contain coordinates[k]

Dynamic Programming with Sorting — Algorithm Steps

Create array of (x, y, original_index) and sort by x-coordinate, then y-coordinate
Use DP to compute longest increasing path ending at each point
Use DP to compute longest increasing path starting from each point
For the point at index k, return dpEnd[k] + dpStart[k] - 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort coordinates

Sort points by x-coordinate, then y-coordinate for efficient processing

Forward DP

Calculate longest increasing path ending at each point

Backward DP

Calculate longest increasing path starting from each point

Combine results

For point k, combine forward and backward paths minus 1

Code -

solution.c — C

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

typedef struct {
    int x, y, idx;
} Coord;

int compareCoords(const void* a, const void* b) {
    Coord* ca = (Coord*)a;
    Coord* cb = (Coord*)b;
    if (ca->x != cb->x) return ca->x - cb->x;
    return ca->y - cb->y;
}

int solution(int coordinates[][2], int n, int k) {
    if (n == 0) return 0;
    
    // Create array with original indices
    Coord* coords = (Coord*)malloc(n * sizeof(Coord));
    for (int i = 0; i < n; i++) {
        coords[i].x = coordinates[i][0];
        coords[i].y = coordinates[i][1];
        coords[i].idx = i;
    }
    
    // Sort by x-coordinate, then by y-coordinate
    qsort(coords, n, sizeof(Coord), compareCoords);
    
    // Find where k ended up after sorting
    int kPos = -1;
    for (int i = 0; i < n; i++) {
        if (coords[i].idx == k) {
            kPos = i;
            break;
        }
    }
    
    // DP for longest increasing path ending at each point
    int* dpEnd = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) dpEnd[i] = 1;
    
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (coords[j].x < coords[i].x && coords[j].y < coords[i].y) {
                if (dpEnd[j] + 1 > dpEnd[i]) {
                    dpEnd[i] = dpEnd[j] + 1;
                }
            }
        }
    }
    
    // DP for longest increasing path starting from each point
    int* dpStart = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) dpStart[i] = 1;
    
    for (int i = n - 2; i >= 0; i--) {
        for (int j = i + 1; j < n; j++) {
            if (coords[i].x < coords[j].x && coords[i].y < coords[j].y) {
                if (dpStart[j] + 1 > dpStart[i]) {
                    dpStart[i] = dpStart[j] + 1;
                }
            }
        }
    }
    
    int result = dpEnd[kPos] + dpStart[kPos] - 1;
    
    free(coords);
    free(dpEnd);
    free(dpStart);
    
    return result;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting plus O(n²) for DP transitions

⚠ Quadratic Growth

Space Complexity

O(n)

Extra space for DP arrays and coordinate sorting

⚡ Linearithmic Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

892 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

Dynamic Programming with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler