Maximum Length Chain of Pairs | DP-20

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. 
Source: Amazon Interview | Set 2
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}}

Method 1: This problem is a variation of standard Longest Increasing Subsequence problem. Following is a simple two step process. 
1) Sort given pairs in increasing order of first (or smaller) element. Why do we need sorting? Consider the example {{6, 8}, {3, 4}} to understand the need of sorting. If we proceed to second step without sorting, we get output as 1. But the correct output is 2. 
2) Now run a modified LIS process where we compare the second element of already finalized LIS with the first element of new LIS being constructed. 
The following code is a slight modification of method 2 of this post.

Length of maximum size chain is 3

Time Complexity: O(n^2) where n is the number of pairs. 

Auxiliary Space: O(n) because of the extra array used to store maximum chain length.

The given problem is also a variation of Activity Selection problem and can be solved in (nLogn) time. To solve it as a activity selection problem, consider the first element of a pair as start time in activity selection problem, and the second element of pair as end time. 

Method 2: 

• Sort given pairs in increasing order of second values.
• Take ans = 0 initially and prev = INT_MIN.
• Now iterate on the given array and if  arr[i].first>prev , then increase answer and set   prev=arr[i].second.
• Finally return answer.

3

Time Complexity: O(n*log₂n).

Auxiliary Space: O(1) as no extra space has been used.

Another approach( Top-down Dynamic programming): Now we will explore the way of solving this problem using the top-down approach of dynamic programming (recursion + memoization). 
Since we are going to solve the above problem using top down method our first step is to figure out the recurrence relation. The best and the easiest way to get the recurrence relation is to think about the choices that we have at each state or position. 
If we look at the above problem carefully, we find two choices to be present at each position/index. The two choices are: 
Choice 1: To select the element at the particular position and explore the rest, (or) 
Choice 2: To leave the element at that position and explore the rest. 
Please note here that we can select the element at a particular position only if first element at that position is greater than the second element that we have previously chosen (this is a constraint given in the question). Hence, in the recursion we maintain a variable which would tell us the previous element that we picked. 
Also, we have to maximize our answer. Hence, we have to find out the maximum resulting option by exploring the above two choices at each position. 
The resulting recurrence relation would be: 

??T(n) = max( maxlenchain(p,n,p[pos].second,0)+1,maxlenchain(p,n,prev_choosen_ele,pos+1) ) 
Please note the function signature is as follows: 
int cal(struct val p[],int n,int prev_choosen_ele,int pos);

Nevertheless, we should not forget our base condition in recursion. If not, our code would enjoy a vacation by just executing forever and not stopping at all. 
So, our base condition for this problem is quite simple. If we reach the end of our exploration, we just return 0, as no more chains would be possible.

??if(pos >= n) return 0;

To avoid the repetitive task, we do the dynamic programming magic (It is a magic to reduce your time complexity). We store the position and previous element in a map. If we ever happened to come to the same position with the same previous element we do not recompute again. We just return the answer from the map.
Below is the implementation of the above approach:

3

Time Complexity: O(n²).
Auxiliary Space: O(n²), due to the use of a map to store previously calculated values.