拜托，别再问我贪心算法了！

    public    class Solution {
    /**
     *  获取能分配给小孩且符合条件的最多糖果数
     */
        private     static     int dispatchCandy(    int[] gList,     int[] sList){
        Arrays.sort(gList);     // 小孩对糖果的需求从小到大排列
        Arrays.sort(sList);     // 糖果大小从小到大排列

            int maximumCandyNum = 0;
            for (    int i = 0; i < gList.length; i++) {
                for (    int j = 0; j < sList.length; j++) {
                // 选择最接近小孩需求的糖果，以便让更大的糖果满足需求更大的小孩
                    if (gList[i] <= sList[j]) {
                    maximumCandyNum++;
                    // 糖果被选中，将其置为-1，代表无效了
                    sList[j] = -1;
                    // 当前小孩糖果已选中，跳出
                        break;
                }
            }
        }
            return maximumCandyNum;
    }

        public     static      void main(String[] args){
        // 小孩对糖果的需求
            int[] gList = {1,2,4,6};
        // 糖果实际大小
            int[] sList = {1,2,7,3};
            int result = dispatchCandy(gList, sList);
        System.out.println("result = " + result);
    }
}

    public    class Solution {
    // 区间类，包括起始值和终止值
        private     static     class Interval {
            int start;
            int end;
        Interval(    int start,     int end) {
                this.start = start;
                this.end = end;
        }
    }

        private     static Integer removeDuplicateIntervas(Interval[] intervals){
        // 将区间按起始点由小到大进行排序
        Arrays.sort(intervals, Comparator.comparingInt(a -> a.start));
        // 首次遍历从 -1,0 开始
            return removeSubDuplicate(-1, 0, intervals);
    }

        private     static Integer removeSubDuplicate(    int pre,     int{
            if (cur == intervals.length) {
                return 0;
        }

            int notRemove = Integer.MAX_VALUE;
            if (pre == -1 || intervals[pre].end <= intervals[cur].start) {

            /**
             * 如果是首次遍历，或者 pre 区间的终点小于 cur 区间的起点（即区间不重叠）,
             * 则 pre = cur; cur = cur+1
             */
            notRemove = removeSubDuplicate(cur, cur+1, intervals);
        }

        /**
         * 如果 pre 区间的终点大于 cur 区间的起点，代表两区间重叠，cur 指向后一个区间，即 cur = cur + 1
         * 代表 cur 被移除，所以需要加1（代表这个区间被移除了）
         */
            int remove = removeSubDuplicate(pre, cur+1, intervals) + 1;

        // 取两者的较小值
            return Math.min(notRemove, remove);
    }

        public     static      void main(String[] args){
        // 初始化区间
        Interval[] intervals = {
                    new Interval(1, 2),
                    new Interval(3, 5),
                    new Interval(4, 7),
                    new Interval(8, 10),
                    new Interval(9, 11)
        };
            int result = removeDuplicateIntervas(intervals);
        System.out.println("result = " + result);
    }
}

11010
11001

// 保存中间结果
    private    static HashMap<String, Integer> map =     new HashMap();
    private     static Integer removeSubDuplicate(    int pre,     int{
    String key = pre + "," + cur;
        if (map.get(key) !=     null) {
            return map.get(key);
    }
    
        if (cur == intervals.length) {
            return0;
    }

        int notRemove = Integer.MAX_VALUE;
        if (pre == -1 || intervals[pre].end <= intervals[cur].start) {
        notRemove = removeSubDuplicate(cur, cur+1, intervals);
    }

        int remove = removeSubDuplicate(pre, cur+1, intervals) + 1;
        int result = Math.min(notRemove, remove);
    map.put(key, result);
        return result;
}

dp[i] = max{dp[j]} + 1, 其中 0 <=j < i 并且需要满足一个条件 interval[i].start > interval[j].end,即保证 i, j 指向的区间不重叠。

/**
* 判断两区间是否重叠, i 区间的起点比 j 区间的大, 如果 j 区间的终点比 i 区间的起点大，则重叠
 */
    private     static     boolean isOverlapping(Interval i, Interval j){
        return j.end > i.start;
}

/**
 * 动态规划求解
 */
    private     static Integer removeSubDuplicateWithDP(Interval[] intervals){
    // 将区间按起始点由小到大进行排序
    Arrays.sort(intervals, Comparator.comparingInt(a -> a.start));

        int[] dp =     new    int[intervals.length];
    Arrays.fill(dp, 0);
    dp[0]  = 1;    // 将 dp[0] 置为 1， 因为就算所有的区间都重叠，则连续不重叠区间到少也为 1

        int result = 1;
        for (    int i = 1; i < intervals.length; i ++) {
            int max = 0;
            for (    int j = 0; j < i; j ++) {
                if (!isOverlapping(intervals[i], intervals[j])) {
                max = Math.max(dp[j], max);
            }
        }
        dp[i] = max + 1;
    }
        return intervals.length - dp[intervals.length - 1];
}

/**
 * 贪心算法求解
 */
    private     static Integer removeSubDuplicateWithGreedy(Interval[] intervals){
    // 将区间终点由小到大进行排序
    Arrays.sort(intervals, Comparator.comparingInt(a -> a.end));

        int cur = 0;            // 设置第一个为当前区间
        int count = 1;      // 最大不重叠区间数,最小为1
        for (    int i = 1; i < intervals.length; i++) {
        // 不重叠
            if (intervals[cur].end < intervals[i].start) {
            cur = i;
            count++;
        }
    }
    // 总区间个数减去最大不重叠区间数即最小被移除重叠区间
        return intervals.length - count;
}