太难了 不会写 试试写过程分析吧 方法一 哈希表+最小堆

 1 class Solution {
 2     public boolean isPossible(int[] nums) {
 3         Map<Integer, PriorityQueue<Integer>> map = new HashMap<Integer, PriorityQueue<Integer>>();
 4         for (int x : nums) {
 5             if (!map.containsKey(x)) {
 6                 map.put(x, new PriorityQueue<Integer>());
 7             }
 8             if (map.containsKey(x - 1)) {
 9                 int prevLength = map.get(x - 1).poll();
10                 if (map.get(x - 1).isEmpty()) {
11                     map.remove(x - 1);
12                 }
13                 map.get(x).offer(prevLength + 1);
14             } else {
15                 map.get(x).offer(1);
16             }
17         }
18         Set<Map.Entry<Integer, PriorityQueue<Integer>>> entrySet = map.entrySet();
19         for (Map.Entry<Integer, PriorityQueue<Integer>> entry : entrySet) {
20             PriorityQueue<Integer> queue = entry.getValue();
21             if (queue.peek() < 3) {
22                 return false;
23             }
24         }
25         return true;
26     }
27 }

1：!map.containsKey(1) => map现状: {1: [ ]}

     !map.containsKey(1 - 1) => map.get(1).offer(1) => map现状: {1: [1]}

2: !map.containsKey(2) => map现状: {1: [1] --------------------------------------------↓

                                                             2: [ ] } => map.containsKey(1)  => prevLength = map.get(1).poll() => poll()后1的Queue为empty => map更新为:{2: [2]}

3:!map.containsKey(3)  => map现状:{2: [2]----------------------------------------------↓

                                                           3: [ ] } => map.containsKey(2) => prevLength = map.get(2).poll() => poll()后2的Queue为empty => map更新为:{3: [3]}

3:不满足前两个if循环 进入 else =>map更新为: {3: [1, 3] }

4:!map.contains(4) => map更新: {3: [1, 3]

　　　　　　　　　　　　　　   4: [ ] } => map.contansKey(3） => prevLength = map.get(3).poll() =>

　　　　　　　　　　　　　　　　poll()后3的Queue不为empty map 更新为{3: [3]

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 4: [2]}

4: map.containsKey(3) => prevLength = 3 =>map.get(3).isEmpty 为空 =>  map更新为{4: [ 4, 2] }

5: map.containsKey(4) => prevLength = 2 =>map.get(4).isEmpty 不为空 => map更新为{4: [4]

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　5: [3]}

5:map.containsKey(4) => prevLength =4 =>map.get(4).isEmpty为空 => map更新为 {5: [3, 5] }

最后呢 就是遍历一下map中的PriorityQueue 如果有<3的就返回false

 

思路呢 这里抄力扣的答案力：

遍历数组，当遍历到元素 xx 时，可以得到一个以 xx 结尾的子序列。

如果哈希表中存在以 x-1x−1 结尾的子序列，则取出以 x-1x−1 结尾的最小的子序列长度，将子序列长度加 11 之后作为以 xx 结尾的子序列长度。此时，以 x-1x−1 结尾的子序列减少了一个，以 xx 结尾的子序列增加了一个。

如果哈希表中不存在以 x-1x−1 结尾的子序列，则新建一个长度为 11 的以 xx 结尾的子序列。

 

 1 class Solution {
 2     public boolean isPossible(int[] nums) {
 3         Map<Integer, Integer> countMap = new HashMap<Integer, Integer>();
 4         Map<Integer, Integer> endMap = new HashMap<Integer, Integer>();
 5         for (int x : nums) {
 6             int count = countMap.getOrDefault(x, 0) + 1;
 7             countMap.put(x, count);
 8         }
 9         for (int x : nums) {
10             int count = countMap.getOrDefault(x, 0);
11             if (count > 0) {
12                 int prevEndCount = endMap.getOrDefault(x - 1, 0);
13                 if (prevEndCount > 0) {
14                     countMap.put(x, count - 1);
15                     endMap.put(x - 1, prevEndCount - 1);
16                     endMap.put(x, endMap.getOrDefault(x, 0) + 1);
17                 } else {
18                     int count1 = countMap.getOrDefault(x + 1, 0);
19                     int count2 = countMap.getOrDefault(x + 2, 0);
20                     if (count1 > 0 && count2 > 0) {
21                         countMap.put(x, count - 1);
22                         countMap.put(x + 1, count1 - 1);
23                         countMap.put(x + 2, count2 - 1);
24                         endMap.put(x + 2, endMap.getOrDefault(x + 2, 0) + 1);
25                     } else {
26                         return false;
27                     }
28                 }
29             }
30         }
31         return true;
32     }
33 }

方法二 贪心 这个力扣写的挺明白的 就不说了

又是做不出日常的一天 难顶 真有你的啊 力扣