LeetCode刷题笔记 659. 分割数组为连续子序列*

最新推荐文章于 2021-08-26 15:16:42 发布

XIIV13

最新推荐文章于 2021-08-26 15:16:42 发布

阅读量185

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode笔记

本文链接：https://blog.youkuaiyun.com/XIIV13/article/details/89884171

LeetCode笔记专栏收录该内容

156 篇文章

订阅专栏

本文探讨了如何将升序整数数组分割成包含至少三个连续整数的子序列，通过详细解析两种算法实现，包括状态压缩DP算法和贪心算法，提供了具体的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

输入一个按升序排序的整数数组（可能包含重复数字），你需要将它们分割成几个子序列，其中每个子序列至少包含三个连续整数。返回你是否能做出这样的分割？

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

总结

SC第一个for会生成类似[0,0,1,1,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0]这样的数组，
入return false的if条件a+b < dp[i]，意思是根据所在位置两边连续数的数量情况，要么两侧一边一个，要么单边最小值>=自己的数量。

SDC思路：贪心算法
endNumMap存储已经三个连续的子序列的数的数量，然后每次循环先找endNumMap，看能不能连在后面，如果不能，则需要往后判断能不能生成新的子序列。
这个算法重要的地方在于123456可以不分割

Sample Code

class Solution {
    public boolean isPossible(int[] nums) {
        int[] dp = new int[2*nums.length+4];
        int last = Integer.MIN_VALUE;
        int k = 1;		//为了兼容后面的i-1，i-2，所以不能取-1
        int i = 0;
        
        while(i<nums.length) {
            int sum = 1;
            while(i<nums.length-1 && nums[i+1]==nums[i]){
                sum++;
                i++;
            }            
            
            if(nums[i] != last + 1)
                k++; 
            
            dp[k++] = sum;
            last = nums[i];
            i++;
        }

        for(i = 2 ; i < k ; i++) {
            if(dp[i] == 0)
                continue;
            if(dp[i-1]==dp[i] && dp[i]==dp[i+1])
                continue;

            int a = Math.min(dp[i-1],dp[i-2]);
            int b = Math.min(dp[i+1],dp[i+2]);
            if(a+b < dp[i]){
            	// if(dp[i-1] >= dp[i]-b && dp[i+1] >= dp[i]-a)	//预防两个Math.min都取到最远两边特殊情况，同下
                if(dp[i-1]-a >= dp[i]-(a+b) && dp[i+1]-b >= dp[i]-(a+b)) //原答案这么写是为了方便阅读吗
                    continue;
                return false;
            }
        }
        return true;
    }
}

Sample & Demo Code

class Solution {
    public boolean isPossible(int[] nums) {
        if(nums.length < 3) return false;
        Map<Integer, Integer> curNumMap = new HashMap<>();
        for(int i = 0; i < nums.length; i++) 
            curNumMap.put(nums[i], curNumMap.getOrDefault(nums[i], 0) + 1);
        
        Map<Integer, Integer> endNumMap = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            int k = nums[i];
            int v = curNumMap.get(k);
            if(v == 0) continue;
            if(endNumMap.containsKey(k-1) && endNumMap.get(k-1) > 0) {
                curNumMap.put(k, curNumMap.get(k) - 1);
                endNumMap.put(k-1, endNumMap.get(k-1) - 1);
                endNumMap.put(k, endNumMap.getOrDefault(k, 0) + 1);
            }else if(curNumMap.containsKey(k+1) && curNumMap.containsKey(k+2) 
            			&& curNumMap.get(k+1) > 0 && curNumMap.get(k+2) > 0) {
                curNumMap.put(k, curNumMap.get(k) - 1);
                curNumMap.put(k+1, curNumMap.get(k+1) - 1);
                curNumMap.put(k+2, curNumMap.get(k+2) - 1);
                endNumMap.put(k+2, endNumMap.getOrDefault(k+2, 0) + 1);
            }else {
                return false;
            } 
                
        }
        return true;
    }
}