算法：分割数组为连续子序列

题目
leetcode659
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

这道题用我的思路，会超时。
其实个人认为只是用的算法不够最优。
思路如下：

public boolean isPossible(int[] nums) {
//        用hash表存nums中每个数字的个数
        int temp_size = nums.length;
        if(temp_size<3){
            return false;
        }

        LinkedHashMap<Integer,Integer> temp = new LinkedHashMap<>();


        for (int i:nums){
            int value;
            if (temp.get(i)!=null){
                value = temp.get(i)+1;
            }else{
                value = 1;
            }
            temp.put(i,value);
        }
        System.out.println(temp.toString());

        // 遍历 nums，每个值为i，从hashmap中取出对应元素i的个数，每个放入一个数组中，
        LinkedList<LinkedList<Integer>> lists = new LinkedList<>();


        for (int i:nums){
            
            while (temp.get(i)!=null && temp.get(i)>0){
                // 确认这个i放入那个数组，这个数组的最后一个数字为i-1，并且长度最小
                LinkedList<Integer> middle = new LinkedList<>();
                int middle_len = Integer.MAX_VALUE;
                boolean find = false;
                for (LinkedList item:lists){
                    if ((int)item.get(item.size()-1)==(i-1) && item.size()<=middle_len){
                        middle = item;
                        middle_len = middle.size();
                        find = true;
                    }
                }
                middle.addLast(i);
                // 每次取一个 i ，map中i对应的个数-1
                int value = temp.get(i)-1;
                temp.put(i,value);
                if (!find){
                    lists.addLast(middle);
                }
            }
        }
        // 计算 lists中每个数组的长度，只要有小于3的，就返回false
        System.out.println(lists.toString());
        for (LinkedList i:lists){
            if (i.size()<3){
                return false;
            }
        }
        return true;

    }

官方解法不会超时，是因为官方用了小顶堆，并且没有那么多遍历。
只有一次遍历。直接计算nums中每一个元素作为最后一个元素的最小长度。

class Solution {
    public boolean isPossible(int[] nums) {
        HashMap<Integer,PriorityQueue<Integer>> map = new HashMap<>();
        for (int i:nums){
            if (!map.containsKey(i)){
                map.put(i,new PriorityQueue<Integer>());
            }
            if (map.containsKey(i-1)){
                int prelen = map.get(i-1).poll();
                if (map.get(i-1).isEmpty()){
                    map.remove(i-1);
                }
                map.get(i).offer(prelen+1);
            }else{
                map.get(i).offer(1);
            }
        }
        Set<Map.Entry<Integer, PriorityQueue<Integer>>> mapset = map.entrySet();
        for (Map.Entry<Integer,PriorityQueue<Integer>> i:mapset){
            if (i.getValue().peek()<3){
                return false;
            }
        }
        return true;
    }
}