Maximum Length of Pair Chain

Maximum Length of Pair Chain - Problem

You are given an array of n pairs pairs where pairs[i] = [left_i, right_i] and left_i < right_i.

A pair p2 = [c, d] follows a pair p1 = [a, b] if b < c. A chain of pairs can be formed in this fashion.

Return the length of the longest chain which can be formed. You do not need to use up all the given intervals. You can select pairs in any order.

Input & Output

Example 1 — Basic Chain

$ Input: pairs = [[1,2],[2,3],[3,4]]

› Output: 2

💡 Note: The longest chain is [1,2] → [3,4]. We can't use [2,3] because 2 is not less than 2.

Example 2 — All Can Chain

$ Input: pairs = [[1,2],[7,8],[4,5]]

› Output: 3

💡 Note: After sorting by end time: [1,2] → [4,5] → [7,8]. All pairs can form a valid chain.

Example 3 — No Chaining Possible

$ Input: pairs = [[1,4],[2,3]]

› Output: 1

💡 Note: Cannot chain [1,4] → [2,3] because 4 ≥ 2. Maximum chain length is 1.

Constraints

n == pairs.length
1 ≤ n ≤ 1000
-1000 ≤ left_i < right_i ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 F Facebook 8

The key insight is that this is an activity selection problem. The greedy approach works optimally: sort pairs by end time and greedily select non-overlapping pairs. Time: O(n log n), Space: O(1).

Common Approaches

✓ Optimized

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

Two Pointers

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

Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ × n) Space: O(n)

Try every possible combination of pairs and check if they can form a valid chain. For each combination, verify that consecutive pairs satisfy the chaining condition.

Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

Sort pairs by start time, then use dynamic programming similar to Longest Increasing Subsequence. For each pair, find the longest chain ending at that pair.

Greedy - Activity Selection

⏱️ Time: O(n log n) Space: O(1)

Sort pairs by their end time, then greedily select pairs. Always choose the pair with the earliest end time among those that can extend the current chain.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long solution(int* nums, int numsSize, int m) {
    long long maxProduct = LLONG_MIN;
    
    // Try each element as the first element
    for (int i = 0; i <= numsSize - m; i++) {
        // Try each valid element as the last element
        for (int j = i + m - 1; j < numsSize; j++) {
            long long product = (long long)nums[i] * nums[j];
            if (product > maxProduct) {
                maxProduct = product;
            }
        }
    }
    
    return maxProduct;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int m;
    scanf("%d", &m);
    
    long long result = solution(nums, numsSize, m);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

98.0K Views

Medium Frequency

~15 min Avg. Time

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