LeetCode Split Array into Consecutive Subsequences

原题链接在这里：https://leetcode.com/problems/split-array-into-consecutive-subsequences/description/

题目：

You are given an integer array sorted in ascending order (may contain duplicates), you need to split them into several subsequences, where each subsequences consist of at least 3 consecutive integers. Return whether you can make such a split.

Example 1:

Input: [1,2,3,3,4,5]
Output: True
Explanation:
You can split them into two consecutive subsequences :
1, 2, 3
3, 4, 

Example 2:

Input: [1,2,3,3,4,4,5,5]
Output: True
Explanation:
You can split them into two consecutive subsequences :
1, 2, 3, 4, 5
3, 4, 5

Example 3:

Input: [1,2,3,4,4,5]
Output: False

Note:

1. The length of the input is in range of [1, 10000]

题解：

对于当前distinct数字 cur, 保存以它结尾的长度1, 2, 和>=3的subsequences数目. count是cur的frequency.

当前个distinct值pre, 如果pre+1 != cur, 说明cur只能用来起头新的subsequence, 但如果前面的噗p1或p2不为0, 说明前面的只能组成长度为1或2的subsequence, return false.

如果pre+1 == cur, 说明cur可以用来append前面的subsequence.

前面长度为1的subsequence个数就是现在长度为2的subsequence个数. c2=p1.

前面长度为2的subsequence个数就是现在长度为3的subsequence个数. 若前面有长度大于3的, 这里可以继续append组成长度大于4的. 但前提是先满足前面长度1和2后剩下的. c3 = p2 + Math.min(p3, count-(p1+p2)).

也可以开始组成新的长度为1的subsequence, 前提是前面用剩下的. c1 = Math.max(0, count-(p1+p2+p3)).

Time Complexity: O(nums.length). Space: O(1).

AC Java:

 class Solution {
     public boolean isPossible(int[] nums) {
         int pre = Integer.MIN_VALUE;
         int p1 = 0;
         int p2 = 0;
         int p3 = 0;
         int cur = 0;
         int c1 = 0;
         int c2 = 0;
         int c3 = 0;
         int count = 0;
 
         int i = 0;
         while(i<nums.length){
             for(cur = nums[i], count = 0; i<nums.length && cur==nums[i]; i++){
                 count++;
             }
 
             if(cur != pre+1){
                 if(p1!=0 || p2!=0){
                     return false;
                 }
 
                 c1 = count;
                 c2 = 0;
                 c3 = 0;
             }else{
                 if(count < p1+p2){
                     return false;
                 }
 
                 c1 = Math.max(0, count-(p1+p2+p3));
                 c2 = p1;
                 c3 = p2 + Math.min(p3, count-(p1+p2));
             }
 
             pre=cur;
             p1=c1;
             p2=c2;
             p3=c3;
         }
         return p1==0 && p2==0;
     }
 }

如果给出的nums不是sorted的, 则可先统计数字的frequency.

再扫一遍nums array, 对于每个数字要么能承上, 要么能启下.

都不能就return false.

Time Complexity: O(nums.length).

Space: O(nums.length).

AC Java:

 class Solution {
     public boolean isPossible(int[] nums) {
         HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
         for(int num : nums){
             hm.put(num, hm.getOrDefault(num, 0)+1);
         }
 
         HashMap<Integer, Integer> append = new HashMap<Integer, Integer>();
         for(int num : nums){
             if(hm.get(num) == 0){
                 continue;
             }
 
             if(append.getOrDefault(num, 0) > 0){
                 append.put(num, append.get(num)-1);
                 append.put(num+1, append.getOrDefault(num+1, 0)+1);
             }else if(hm.getOrDefault(num+1, 0) > 0 && hm.getOrDefault(num+2, 0) > 0){
                 hm.put(num+1, hm.get(num+1)-1);
                 hm.put(num+2, hm.get(num+2)-1);
                 append.put(num+3, append.getOrDefault(num+3, 0)+1);
             }else{
                 return false;
             }
 
             hm.put(num, hm.get(num)-1);
         }
 
         return true;
     }
 }