Maximum Length of Pair Chain - Practice Coding Problems

Maximum Length of Pair Chain - Problem

You're given an array of n pairs where each pair is represented as pairs[i] = [left_i, right_i] with left_i < right_i.

A pair p2 = [c, d] can follow a pair p1 = [a, b] if b < c (the right value of the first pair is strictly less than the left value of the second pair).

Your goal is to form the longest possible chain of pairs following this rule. You can select pairs in any order and don't need to use all pairs.

Example:
Input: [[1,2], [2,3], [3,4]]
Output: 2 (chain: [1,2] → [3,4])
Note: [2,3] cannot follow [1,2] since 2 is not less than 2

Input & Output

example_1.py — Basic Chain

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

› Output: 2

💡 Note: The longest chain is [1,2] → [3,4]. Note that [2,3] cannot follow [1,2] because 2 is not strictly less than 2.

example_2.py — Multiple Valid Chains

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

› Output: 3

💡 Note: All pairs can be chained together: [1,2] → [4,5] → [7,8], giving us a chain of length 3.

example_3.py — Single Pair

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

› Output: 1

💡 Note: With only one pair, the maximum chain length is 1.

Visualization

Tap to expand

Understanding the Visualization

Sort by End Time

Arrange all meetings by when they end - this is key to the greedy strategy

Pick Earliest Ending

Always select the meeting that ends earliest among available options

Check Compatibility

Only book meetings that start after the previous one completely ends

Maximize Bookings

This greedy choice leads to the maximum number of scheduled meetings

Key Takeaway

🎯 Key Insight: Sorting by end time and using a greedy approach guarantees the maximum chain length because it always preserves the most opportunities for future selections.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n!)

2^n subsets, each potentially requiring n! permutations to check

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current chain

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000 where n is the length of pairs
-1000 ≤ left_i < right_i ≤ 1000
left_i < right_i for all pairs

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a greedy approach with sorting. Sort pairs by their end times, then greedily select pairs that don't overlap. This works because choosing the earliest-ending pair always maximizes future opportunities, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n!)	O(n)	Try every possible subset of pairs and check if they form a valid chain
Greedy Approach (Sort by End Time)	O(n log n)	O(1)	Sort pairs by end time and greedily select non-overlapping pairs

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of the given pairs
For each subset, try all permutations to see if any forms a valid chain
A valid chain means each pair can follow the previous one (prev[1] < curr[0])
Keep track of the maximum chain length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible combinations of pairs

Check Validity

For each subset, verify if pairs can form a valid chain

Find Maximum

Track the longest valid chain found

Code -

solution.c — C

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

bool canChain(int chain[][2], int len) {
    for (int i = 1; i < len; i++) {
        if (chain[i-1][1] >= chain[i][0]) {
            return false;
        }
    }
    return true;
}

int backtrack(int pairs[][2], int pairsLen, int index, int chain[][2], int chainLen) {
    if (index == pairsLen) {
        return canChain(chain, chainLen) ? chainLen : 0;
    }
    
    // Don't include current pair
    int maxLen = backtrack(pairs, pairsLen, index + 1, chain, chainLen);
    
    // Try including current pair at each position
    for (int i = 0; i <= chainLen; i++) {
        // Shift elements to make room
        for (int j = chainLen; j > i; j--) {
            chain[j][0] = chain[j-1][0];
            chain[j][1] = chain[j-1][1];
        }
        chain[i][0] = pairs[index][0];
        chain[i][1] = pairs[index][1];
        
        int result = backtrack(pairs, pairsLen, index + 1, chain, chainLen + 1);
        if (result > maxLen) maxLen = result;
        
        // Shift back
        for (int j = i; j < chainLen; j++) {
            chain[j][0] = chain[j+1][0];
            chain[j][1] = chain[j+1][1];
        }
    }
    
    return maxLen;
}

int findLongestChain(int pairs[][2], int n) {
    int chain[1000][2]; // Assuming max 1000 pairs
    return backtrack(pairs, n, 0, chain, 0);
}

int main() {
    int n;
    scanf("%d", &n);
    int pairs[1000][2];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &pairs[i][0], &pairs[i][1]);
    }
    printf("%d\n", findLongestChain(pairs, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n!)

2^n subsets, each potentially requiring n! permutations to check

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current chain

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000 where n is the length of pairs
-1000 ≤ left_i < right_i ≤ 1000
left_i < right_i for all pairs

68.2K Views

Medium Frequency

~15 min Avg. Time

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler