646. Maximum Length of Pair Chain

646. Maximum Length of Pair Chain

1. 题目
题目链接

You are given n pairs of numbers. In every pair, the first number is always smaller than the second number.
Now, we define a pair (c, d) can follow another pair (a, b) if and only if b < c. Chain of pairs can be formed in this fashion.
Given a set of pairs, find the length longest chain which can be formed. You needn’t use up all the given pairs. You can select pairs in any order.
Example 1:
Input: [[1,2], [2,3], [3,4]]
Output: 2
Explanation: The longest chain is [1,2] -> [3,4]
Note:
The number of given pairs will be in the range [1, 1000].

2. 题目分析
题目要求找最长的链，链的要求是前面那“对数”的第二个元素(end)小于后面那“对数”的第一个元素，其实跟合并区间的那题差不多。我这里就方便，就把那“对数”称为区间吧。

3. 解题思路
题目没有明说，这些区间是有序的，所以为了方便进行比较，可以先排序。刚开始，我的想法是以每个区间的开始元素进行排序，如[1,10],[7,9],[2,6]，进行排序后[1,10],[2,6],[7,9]，然后用dp[i]，表示从第0个区间到第i个区间的最大链长度。接着对每个比当前区间的开始元素小的区间的链表长度加1，最后找最大长度，即dp[i] = Math.max(dp[i],dp[j]+1) (0<=j<=i);。

代码实现（java）

public static int findLongestChain(int[][] pairs) {
        if (pairs == null){
            return 0;
        }
        Pair pair;
        int len = pairs.length;
        List<Pair> pairList = new ArrayList<>(pairs.length);
        for (int i = 0; i < len; i++) {
            pair = new Pair(pairs[i][0],pairs[i][1]);
            pairList.add(pair);
        }
        
        //对pair以start进行排序
        Collections.sort(pairList, new Comparator<Pair>() {
            @Override
            public int compare(Pair o1, Pair o2) {
                return o1.start - o2.start;
            }
        });

        int[] dp =new int[len];
        dp[0] = 1;
        int max = 1;
        for (int i = 1; i < len; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (pairList.get(i).start > pairList.get(j).end){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                    if (dp[i] > max){
                        max = dp[i];
                    }
                }
            }
        }
        return max;
    }
}

这个提交后是ac的，但我查看明细的时候，发现只超过9%（黑人问号？？？），仔细分析一下，排序时间复杂度为O(nlogn)，找最大链长度O(n2)，所以总的时间复杂度为O(nlogn)+O(n2);看了一下超过100%的大佬的解答，发现思路是一样的（先排序，然后通过比较找最长链），区别是他们用的是以区间的end进行排序，研究了一下，这样有个好处，通过区间的end进行排序后，可以直接进行线性比较，即时间复杂度变为O(n)，秒，真的秒！
以下源码有大佬的实现方式，也有我自己的实现方式。

4. 代码实现（java）

package com.algorithm.leetcode.dynamicAllocation;

import java.util.*;

/**
 * Created by 凌 on 2019/1/28.
 * 注释：646. Maximum Length of Pair Chain
 */
public class FindLongestChain {
    public static void main(String[] args) {
        int[][] pairs = {{-6,9},{1,6},{8,10},{-1,4},{-6,-2},{-9,8},{-5,3},{0,3}};
//        int[][] pairs = {{1,10},{2,6},{8,9}};
        int result = findLongestChain(pairs);
        System.out.println(result);

        result = findLongestChain_1(pairs);
        System.out.println(result);
    }
    public static int findLongestChain(int[][] pairs) {
        if (pairs == null){
            return 0;
        }
        Pair pair;
        int len = pairs.length;
        List<Pair> pairList = new ArrayList<>(pairs.length);
        for (int i = 0; i < len; i++) {
            pair = new Pair(pairs[i][0],pairs[i][1]);
            pairList.add(pair);
        }
        //对pair以end进行排序
        Collections.sort(pairList, new Comparator<Pair>() {
            @Override
            public int compare(Pair o1, Pair o2) {
                return o1.end - o2.end;
            }
        });
        int max = 1;
        int end = pairList.get(0).end;
        for (int i = 1; i < len; i++) {
            if (pairList.get(i).start > end) {
                max++;
                end = pairList.get(i).end;
            }
        }
        return max;
    }

    /**
     * 参考答案，以end进行排序
     * @param pairs
     * @return
     */
    public static int findLongestChain_1(int[][] pairs) {
        Arrays.sort(pairs,new Comparator<int[]>(){
            @Override
            public int compare(int[] arg0, int[] arg1) {
                return arg0[1]-arg1[1];
            }
        });

        int count = 1;
        int end = pairs[0][1];

        for(int i=1;i<pairs.length;i++) {
            if(pairs[i][0]>end) {
                count++;
                end = pairs[i][1];
            }
        }
        return count;
    }
}
class Pair{
    public int start;
    public int end;

    public Pair(int start, int end) {
        this.start = start;
        this.end = end;
    }
}