Length of the Longest Increasing Path

Start by considering binary search over the valid answer space to quickly narrow potential path lengths. Filter coordinates to keep only points with both x and y strictly less than the target coordinate. Combine sorting and memoized DFS to compute the maximum increasing path length including the specified point efficiently.

Problem Statement

You are given a 2D array coordinates of length n and an integer k, where each coordinates[i] = [xi, yi] represents a point on a 2D plane. An increasing path is a sequence of points where each subsequent point has strictly greater x and y values than the previous one.

The goal is to find the length of the longest increasing path that includes the point at index k. Only paths that respect the strictly increasing x and y constraint are valid. Return the maximum number of points in such a path.

Examples

Example 1

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

Output: 3

(0, 0) , (2, 2) , (5, 3) is the longest increasing path that contains (2, 2) .

Example 2

Input: coordinates = [[2,1],[7,0],[5,6]], k = 2

Output: 2

(2, 1) , (5, 6) is the longest increasing path that contains (5, 6) .

Constraints

• 1 <= n == coordinates.length <= 105
• coordinates[i].length == 2
• 0 <= coordinates[i][0], coordinates[i][1] <= 109
• All elements in coordinates are distinct.
• 0 <= k <= n - 1

Solution Approach

Binary Search Over Answer Length

Use binary search to guess the possible maximum path length. For each candidate length, check if a path of that length exists including coordinates[k] by filtering points with both x and y strictly less than coordinates[k]. This reduces unnecessary computations and quickly narrows the valid answer space.

Sort and Prepare Points

Sort coordinates based on x and y values to facilitate efficient subsequence calculations. Keep only points relevant to building a path including coordinates[k], reducing the dataset to the minimal required subset.

Dynamic Programming / Memoized DFS

Traverse the filtered points using memoized DFS to compute the longest increasing subsequence starting or ending at each point. Store intermediate results to avoid recalculating overlapping subpaths, ensuring time efficiency on large input sizes.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity mainly depends on the binary search iterations multiplied by the DFS or DP over filtered points, which is faster than brute force. Space complexity comes from memoization storage and the temporary filtered list, typically O(n) in the worst case.

What Interviewers Usually Probe

• Pay attention to filtering coordinates based on both x and y to avoid invalid paths.
• Consider using binary search over the maximum path length to reduce brute-force attempts.
• Sorting the coordinates before DFS simplifies subsequence calculations and improves efficiency.

Common Pitfalls or Variants

Common pitfalls

• Not filtering coordinates strictly less than coordinates[k] leads to invalid paths being counted.
• Attempting DFS without memoization causes timeouts for large arrays.
• Confusing increasing path criteria by only checking x or y instead of both.

Follow-up variants

• Compute the longest increasing path without requiring inclusion of a specific point.
• Find the longest decreasing path instead, reversing the comparison conditions.
• Allow non-strictly increasing sequences and measure the longest weakly increasing path.

FAQ

What is the main strategy to solve Length of the Longest Increasing Path efficiently?

The core approach is binary search over the valid path length combined with memoized DFS over filtered and sorted coordinates.

Do we need to check all coordinates when computing the increasing path?

No, only coordinates with both x and y less than the target point need to be considered to ensure valid increasing paths.

Can this problem be solved without sorting the coordinates?

Sorting simplifies subsequence computations and ensures DFS builds paths in order, but brute force without sorting is possible but inefficient.

How does memoization improve performance in this problem?

Memoization stores intermediate longest path lengths from each point, avoiding repeated DFS traversals over the same subpaths.

Is the pattern 'Binary search over the valid answer space' common in other path problems?

Yes, this pattern efficiently narrows potential maximum path lengths and is key to solving problems like this with large input arrays.