还有老师，为什么按照起始位置排序以后就能动态规划求出最长子序列了呢？隐隐约约好像是这样的，但是老是想不清楚。

class Solution {
    public static class Interval {
        int start;
        int end;
        Interval() { start = 0; end = 0; }
        Interval(int s, int e) { start = s; end = e; }
    }
    // 相当于求最长上升子序列，再剪一剪
    public int eraseOverlapIntervals(int[][] intervals) {
        if(intervals.length == 1) return 0;
        Interval[] ranges = new Interval[intervals.length];
        int totalLen = intervals.length;
        for(int i = 0; i < totalLen; i++) {
            ranges[i] = new Interval(intervals[i][0], intervals[i][1]);
        }
        Arrays.sort(ranges, new Comparator<Interval>() {
            @Override
            public int compare(Interval o1, Interval o2) {
                if(o1.start != o2.start)
                    return o1.start - o2.start;
                return o1.end - o2.end;
            }
        });
        int[] memo = new int[intervals.length];
        Arrays.fill(memo, -1);
        int max = 1;
        for(int i = 0; i < totalLen; i++) {
            max = Math.max(max, tryFindMax(i, ranges, memo));
        }
        return totalLen - max;
    }
    // 寻找从 index 开始（必选）的最长上升子序列
    private int tryFindMax(int index, Interval[] intervals, int[] memo) {
        if(index >= intervals.length) return 0;
        if(memo[index] != -1) return memo[index];
        int max = 1;
        for(int next = index + 1; next < intervals.length; next++) {
            int curR = intervals[index].end;
            int nextL = intervals[next].start;
            if(nextL < curR) {
                continue;
            } else {
                max = Math.max(max, 1 + tryFindMax(next, intervals, memo));
            }
        }
        return memo[index] = max;
    }
}

跟老师思路一样，就是换成了递归写法，迭代写法一样超时试了一下