[GeeksForGeeks] Maximum Length Chain of Pairs

You are given n pairs of numbers. In every pair, the first number is always smaller than the second number. A pair (c, d) can follow another pair (a, b) if b < c. Chain of pairs can be formed in this fashion. Find the longest chain which can be formed from a given set of pairs. 

For example, if the given pairs are {{5, 24}, {39, 60}, {15, 28}, {27, 40}, {50, 90} }, then the longest chain that can be formed is of length 3, and the chain is {{5, 24}, {27, 40}, {50, 90}}

 

Solution 1. Dynamic Programming, O(n^2) runtime

This problem looks similar with the Longest Increasing Subsequence but not quite the same. In LIS, the sequence's relative order is given and can not be changed.

In this problem,  we are only given some pairs of numbers and no enforced order, we can rearrange their relative order to get the longest chain.

 

Algorithm:

1. sort the given pairs either by their first numbers or second numbers. Doing this reduces this problem to Longest Increasing Subsequence. 

2.  The LIS problem can be solved using recursion or dynamic programming. 

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

class Pair {
    int first;
    int second;
    Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }
    void display() {
        System.out.println(this.first + ", " + this.second);
    }
}
public class MaxLenChain {
    private int max = 0;
    public int getLongestChainRecursion(Pair[] pairs) {
        if(pairs == null || pairs.length == 0) {
            return 0;
        }
        Comparator<Pair> comp = new Comparator<Pair>(){
            public int compare(Pair p1, Pair p2) {
                return p1.second - p2.second;
            }
        };
        Arrays.sort(pairs, comp);
        for(int i = 0; i < pairs.length; i++) {
            recursionHelper(pairs, i);
        }
        return max;
    }
    private int recursionHelper(Pair[] pairs, int endIdx) {
        int len = 1;
        for(int j = 0; j < endIdx; j++) {
            if(pairs[j].second < pairs[endIdx].first) {
                len = Math.max(len, recursionHelper(pairs, j) + 1);
            }
        }
        if(len > max) {
            max = len;
        }
        return len;
    }
    public int getLongestChainDp(Pair[] pairs) {
        Comparator<Pair> comp = new Comparator<Pair>(){
            public int compare(Pair p1, Pair p2) {
                return p1.second - p2.second;
            }
        };
        Arrays.sort(pairs, comp);
        ArrayList<Pair> longestChain = new ArrayList<Pair>();
        int[] LcEndAt = new int[pairs.length];
        int max = 0; int maxIdx = -1;
        for(int i = 0; i < pairs.length; i++) {
            LcEndAt[i] = 1;
            for(int j = 0; j < i; j++) {
                if(pairs[j].second < pairs[i].first) {
                    LcEndAt[i] = Math.max(LcEndAt[i], LcEndAt[j] + 1);
                }
            }
            if(LcEndAt[i] > max) {
                max = LcEndAt[i];
                maxIdx = i;
            }
        }
        int maxLen = max;
        while(maxLen > 0) {
            longestChain.add(pairs[maxIdx]);
            maxLen--;
            for(int i = 0; i < maxIdx; i++) {
                if(LcEndAt[i] == maxLen){
                    maxIdx = i;
                    break;
                }
            }
        }
        for(int i = longestChain.size() - 1; i >= 0; i--) {
            longestChain.get(i).display();
        }
        return max;
    }
    public static void main(String[] args) {
        Pair p1 = new Pair(5,24);
        Pair p2 = new Pair(39,60);
        Pair p3 = new Pair(15,28);
        Pair p4 = new Pair(27,40);
        Pair p5 = new Pair(50,90);
        Pair[] pairs = {p1,p2,p3,p4,p5};
        /*Pair p1 = new Pair(90,100);
        Pair p2 = new Pair(70,80);
        Pair p3 = new Pair(50,60);
        Pair p4 = new Pair(30,40);
        Pair[] pairs = {p1,p2,p3,p4};*/
        MaxLenChain test = new MaxLenChain();
        System.out.println(test.getLongestChainDp(pairs));
    }
}

 

Solution 2. Greedy Algorithm(Activity Selection Problem), O(n*logn) runtime

This problem is also a variation of Activity Selection Problem and can be solved in O(n*logn) runtime. To solve it as an activity selection problem,

consider the first element of a pair as start time in activity selection problem, and the second element as end time. 

 

Algorithm:

1. sort the activities according to their finishing time.

2. select the first activity from the sorted array as the first activity in the optimal solution.

3. do the following for remaining activities in the sorted array.

    pick the next activity whose finish time is the smallest among the remaining activities and its start time is >= the finish time of previously selected activity.

 

Proof of correctness

Let the give set of activities be S = {1, 2, 3, ..n} and activities be sorted by finish time. The greedy choice is to always pick activity 1. How come the activity 1 always provides one of the optimal solutions. We can prove it by showing that if there is another solution B with first activity other than 1, then there is also a solution A of same size with activity 1 as first activity. Let the first activity selected by B be k, then there always exist A = {B – {k}} U {1}.(Note that the activities in B are independent and k has smallest finishing time among all. Since k is not 1, finish(k) >= finish(1)).

 

public int getLongestChainGreedy(Pair[] pairs) {
    Comparator<Pair> comp = new Comparator<Pair>(){
        public int compare(Pair p1, Pair p2) {
            return p1.second - p2.second;
        }
    };
    Arrays.sort(pairs, comp);
    int maxLen = 1; int prevPicked = 0, currIdx = 1;
    while(currIdx < pairs.length) {
        if(pairs[prevPicked].second <= pairs[currIdx].first) {
            maxLen++;
            prevPicked = currIdx;
        }
        currIdx++;
    }
    return maxLen;
}

 

The same greedy algorithm can also be implemented by sorting for start time and traverse backward. The last activity whose start time is the biggest is always in one of the optimal solution.

 

This problem is similar but not the same with Number of Airplanes in the sky.

Similarity: both problems are given activities with a start and end time.

Difference: This problem looks for the max result "horizontally", Number of Airplanes in the sky looks for the max result "vertically".

This problems looks for the most activities that does not have time overlap;

Number of Airplanes in the sky looks for at any time, the most number of activities that can happen at the same time. 

 

 

Related Problems 

[LintCode] Number of Airplanes in the Sky