[leetCode]659. 分割数组为连续子序列

题目

链接：https://leetcode-cn.com/problems/split-array-into-consecutive-subsequences

给你一个按升序排序的整数数组 num（可能包含重复数字），请你将它们分割成一个或多个子序列，其中每个子序列都由连续整数组成且长度至少为 3 。

如果可以完成上述分割，则返回 true ；否则，返回 false 。

示例 1：

输入: [1,2,3,3,4,5]
输出: True
解释:
你可以分割出这样两个连续子序列 : 
1, 2, 3
3, 4, 5

示例 2：

输入: [1,2,3,3,4,4,5,5]
输出: True
解释:
你可以分割出这样两个连续子序列 : 
1, 2, 3, 4, 5
3, 4, 5

示例 3：

输入: [1,2,3,4,4,5]
输出: False

提示：

输入的数组长度范围为 [1, 10000]

贪心 哈希加优先队列

使用一个哈希表， 键为子序列的最后一个数字，值为最小堆，存储所有子序列的长度。遍历数组nums， 当前数字为x，如果存在以x-1为结尾的子序列，则将x加入以x-1为结尾的子序列中的最短的子序列，这样才能让最短的子序列尽可能的长。然后跟新以x结尾的子序列的长度。如果不存在以x-1为结尾的子序列则需要以x单独新建一个子序列。 最后判断哈希表中每个元素结尾的最短子序列的长度是否大于3， 如果小于3则返回false，否则为true。

class Solution {
    public boolean isPossible(int[] nums) {
        // 键为子序列的最后一个数字， 值为最小堆，存储所有子序列的长度
        Map<Integer, PriorityQueue<Integer>> map = new HashMap<>();
        for (Integer x : nums) {
            if (!map.containsKey(x)) {
                map.put(x, new PriorityQueue<>());
            }
            if (map.containsKey(x - 1)) {
                int prevLen = map.get(x - 1).poll(); // 以 x - 1结尾的最短子序列长度
                if (map.get(x - 1).isEmpty())
                    map.remove(x - 1);
                map.get(x).offer(prevLen + 1); 
            } else {
                map.get(x).offer(1);
            }
        }
        for (Map.Entry<Integer, PriorityQueue<Integer>> entry : map.entrySet()) {
            if (entry.getValue().peek() < 3)
                return false;
        }
        return true;
    }
}

贪心

尽量避免新建短的子序列，使用两个哈希表，第一个哈希表存储数组中的每个数字的剩余次数，第二个哈希表存储数组中的每个数字作为结尾的子序列的数量。
遍历数组初始化第一个哈希表，只有一个数字的出现次数大于0时才需要考虑这个数字是否能加入某个子序列。

• 首先根据第二个哈希表判断以x-1为结尾的子序列的数量是否大于0。如果大于0则将x加入该子序列中，这样x用掉了一次，更新第一个哈希表，将x对应的数量减1。子序列从x-1变为了x，第二个哈希表中x-1为结尾的子序列数量减1，而以x为结尾的子序列数量+1。

• 否则，x为子序列的第一个数，由于子序列长度至少为3，需要判断x+1与x+2的出现次数是否大于0

  • 当都大于0时， 可以新建一个长度为3的子序列[x, x+1, x+2]，同时更新两个哈希表
  • 否则无法新建长度为3的子序列因此无法完成分割返回false

如果整个数组遍历结束时都没有遇到无法完成分割的情况，则返回true

class Solution {
    public boolean isPossible(int[] nums) {
        // 记录每个数字出现的频率
        Map<Integer, Integer> countMap = new HashMap<>();
        // 记录以每个数字作为结尾的子序列的数量
        Map<Integer, Integer> endMap = new HashMap<>();
        // 统计频率
        for (Integer x : nums) {
            countMap.put(x, countMap.getOrDefault(x, 0) + 1);
        }
        for (Integer x : nums) {
            int count = countMap.getOrDefault(x, 0);
            if (count > 0) { // 只有一个数字的剩余出现次数大于0时才需要考虑该数字是否能加入某个子序列
                int prevEndCount = endMap.getOrDefault(x - 1, 0);
                if (prevEndCount > 0) {
                    countMap.put(x, count - 1);
                    endMap.put(x - 1, prevEndCount - 1);
                    endMap.put(x, endMap.getOrDefault(x, 0) + 1);
                } else { // 如果不存在 x - 1 为结尾的子序列
                    int count1 = countMap.getOrDefault(x + 1, 0);
                    int count2 = countMap.getOrDefault(x + 2, 0);
                    if (count1 > 0 && count2 > 0) {
                        countMap.put(x, count - 1);
                        countMap.put(x + 1, count1 - 1);
                        countMap.put(x + 2, count2 - 1);
                        endMap.put(x + 2, endMap.getOrDefault(x + 2, 0) + 1);
                    } else {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}