LeetCode[659]Split Array into Consecutive Subsequences(Java)

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, 5

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:

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

Topic:
힙 (더미) Greedy (탐욕)
Heap:
       스 택 은 '후진 선 출' 알고리즘 을 실행 하 는 데이터 구조 이다.
       스 택 은 바로 이러한 데이터 구조 이다.이것 은 메모리 에 저장 영역 을 열 고 데 이 터 를 순서대로 저장 합 니 다 (즉, '압착 - push'). 이 영역 에 저장 합 니 다.주소 포인터 가 항상 마지막 으로 스 택 에 눌 린 데이터 가 있 는 데이터 셀 을 가리 키 는데 이 주소 포인터 가 저 장 된 레지스터 를 스 택 표시 기 라 고 합 니 다.데 이 터 를 넣 기 시작 한 단원 을 '창고 바닥' 이 라 고 합 니 다.데 이 터 를 하나씩 저장 하 는데 이 과정 을 '스 택 압축' 이 라 고 합 니 다.스 택 을 누 르 는 과정 에서 하나의 데이터 가 스 택 에 쌓 일 때마다 이전 유닛 과 연 결 된 다음 단원 에 놓 여 있 고 스 택 표시 기 에 있 는 주 소 는 자동 으로 1 을 추가 합 니 다.이 데 이 터 를 읽 을 때 스 택 표시 기의 주소 에 따라 데 이 터 를 읽 고 스 택 표시 기의 주소 수가 자동 으로 줄 어 듭 니 다. 1.이 과정 을 팝 업 팝 이 라 고 합 니 다.이렇게 해서 후진 선출 의 원칙 을 실현 하 였 다.
이 진 더 미 는 우선 대기 열의 기본 동작 을 잘 실현 할 수 있다.이 진 더미 의 모든 배열 에서 모든 요 소 는 다른 두 개의 특정한 위치 와 같은 요 소 를 확보 해 야 한다.
쌓 인 성질:
       이 진 트 리 의 모든 결산 점 이 (큰 지붕 더미) 보다 크 거나 (작은 지붕 더미) 와 같은 두 개의 키 의 결산 점 보다 작 을 때 질서 가 있다 고 불 린 다.
       더 미 는 완전히 두 갈래 나무 다.
PriorityQueue 우선 대기 열:
Priority Queue 밑바닥 에서 이 루어 진 데이터 구 조 는 더미 입 니 다.
우선 대기 열 이 자바 에서 사용 하 는 최소 더 미 는 대기 열 에서 꺼 낼 때마다 최소 요소 임 을 의미 합 니 다.
Greedy 욕심:
문 제 를 풀 때 는 항상 현재 로 서 는 가장 좋 은 선택 을 한다.전체적인 최 적 화 를 고려 하지 않 고 특정한 의미 에서 국 지적 으로 최 적 화 된 것 이다.
Solution:
HashMap 저장 키 쌍 만 들 기 (대기 열의 마지막 요소, 대기 열의 길이)

class Solution {
    HashMap> map = new HashMap>();
    public boolean isPossible(int[] nums) {
        for(int num : nums){
            PriorityQueue last = helper(num - 1);
            int len = last.isEmpty()? 0 : last.poll();
            PriorityQueue current = helper(num);
            current.offer(len + 1);
        }
        for(int key : map.keySet()){
            for(int len : map.get(key)){
                if(len < 3){
                    return false;
                }
            }
        }
        return true;
    }
    public PriorityQueue helper(int num){
        PriorityQueue temp = map.get(num);
        if(temp == null){
            temp = new PriorityQueue();
            map.put(num, temp);
        }
        return temp;
    }
}

우선 (num - 1) 을 마지막 으로 하 는 서열 이 존재 하 는 지 판단 하고,
존재 한다 면 길이 최소 값 len 을 가 져 오고 스 택 을 나 가 num 을 마지막 으로 하 는 배열 을 만 들 고 길 이 를 len + 1 로 설정 하여 우선 대기 열 로 밀어 넣 습 니 다.
존재 하지 않 는 다 면, 새로운 시퀀스 를 만 들 고, num 을 끝으로 길이 가 1 이 며, 우선 대기 열 로 밀어 넣 고, 새로운 키 쌍 (num, currentPriority Queue) 을 맵 에 밀어 넣 습 니 다.
1,2,3,3,4,4,5,5
num
last
len
current
map
1
null->(0,[ ])
0
(1, [1])
(0,[ ] ) (1, [1])
2
(1, [1])
1
(2, [2])
(0,[ ] ) (1, [ ])(2, [2])
3
(2, [2])
2
(3, [3])
(0,[ ] ) (1, [ ])(2, [ ])(3, [3])
3
(2, [ ])
0
(3, [1])
(0,[ ] ) (1, [ ])(2, [ ])(3, [3])(3, [1])
4
(3, [1])
1
(4, [2])
(0,[ ] ) (1, [ ])(2, [ ])(3, [3])(3, [ ])(4, [2])
4
(3, [3])
3
(4, [4])
(0,[ ] ) (1, [ ])(2, [ ])(3, [ ])(3, [ ])(4, [2])(4, [4])
5
(4, [2])
2
(5, [3])
(0,[ ] ) (1, [ ])(2, [ ])(3, [ ])(3, [ ])(4, [ ])(4, [4])(5, [3])
5
(4, [4])
4
(5, [5])
(0,[ ] ) (1, [ ])(2, [ ])(3, [ ])(3, [ ])(4, [ ])(4, [ ])(5, [3])(5, [5])
Code: