分割数组为连续子序列- -贪心法

package Leetcode;

import java.util.ArrayList;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Iterator;

/**
 * 给你一个按升序排序的整数数组 num（可能包含重复数字），请你将它们分割成一个或多个子序列，其中每个子序列都由连续整数组成且长度至少为 3 。
 * 如果可以完成上述分割，则返回 true ；否则，返回 false 。
 */
public class fenge {
    public static void main(String[] args) {
        int []nums={0,1,2,3,3,4,5};
        // int[] nums = { -5, -5, -4, -4, -3 };
        System.out.println(isPossible(nums));
    }
    /**
     * 这个只能到最长结尾
     * @param nums
     * @return
     */
    public static boolean isPossible1(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i], map.get(nums[i]) + 1);
            } else {
                map.put(nums[i], 1);
            }
        }

        int[] counts = new int[map.size()];
        for (Integer i : map.keySet()) {
            counts[i - nums[0]] = map.get(i);
        }
        List<List<Integer>> list = new ArrayList<>();

        while (map.size() != 0) {
            List<Integer> r = new ArrayList<>();
            for (Integer i : map.keySet()) {
                
                if (map.get(i) == 0) {
                    continue;
                }
                r.add(i);
                map.put(i, map.get(i) - 1);
            }
            Iterator<Entry<Integer, Integer>> it = map.entrySet().iterator();
            while(it.hasNext()){  
                Entry<Integer, Integer> entry = it.next();
            if(entry.getValue() == 0)  
                it.remove();//使用迭代器的remove()方法删除元素  
            }  
            
            if(r.size()<3){
                
                continue;
            }
            int flag=0;
            Collections.sort(r);
            for(int i=1;i<r.size();i++){
                if(r.get(i)-r.get(i-1)!=1){
                    flag=1;
                    break;
                }
            }
            if(flag==1){
                
                continue;
            }
            
            list.add(r);
            
        }
        if(list.size()>=2){
            return true;
        }
        return false;

    }
    /**
     * 思路：用tail记录结束位置为i的序列个数
     * 1.如果当前的后面两个都存在，以后面第三个结尾+1
     * 2.如果当前的前面一个结尾的长度不为0，把当前的附在前一个上
     * 3.否则false
     */
    public static boolean isPossible(int[] nums){
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i], map.get(nums[i]) + 1);
            } else {
                map.put(nums[i], 1);
            }
        }
        Map<Integer,Integer> tail=new HashMap<Integer,Integer>();
        for(int i:nums){
            int count=map.getOrDefault(i, 0);
            if(count<=0){
                continue;
            }else if(tail.getOrDefault(i-1, 0)>0){
                map.put(i, count-1);
                tail.put(i-1, tail.get(i-1)-1);
                tail.put(i, tail.getOrDefault(i,0)+1);
            }else if(map.getOrDefault(i+1, 0)>0&&map.getOrDefault(i+2, 0)>0){
                map.put(i,count-1);
                map.put(i+1,map.get(i+1)-1);
                map.put(i+2,map.get(i+2)-1);
                tail.put(i+2, tail.getOrDefault(i+2, 0)+1);

            }else{
                return false;
            }
        }
        return true;
    }
}