[프로그래머스] 풍선 터트리기

문제

---

일렬로 나열된 n개의 풍선이 있습니다. 모든 풍선에는 서로 다른 숫자가 써져 있습니다. 당신은 다음 과정을 반복하면서 풍선들을 단 1개만 남을 때까지 계속 터트리려고 합니다.

1. 임의의 인접한 두 풍선을 고른 뒤, 두 풍선 중 하나를 터트립니다.
2. 터진 풍선으로 인해 풍선들 사이에 빈 공간이 생겼다면, 빈 공간이 없도록 풍선들을 중앙으로 밀착시킵니다.

여기서 조건이 있습니다. 인접한 두 풍선 중에서 번호가 더 작은 풍선을 터트리는 행위는 최대 1번만 할 수 있습니다. 즉, 어떤 시점에서 인접한 두 풍선 중 번호가 더 작은 풍선을 터트렸다면, 그 이후에는 인접한 두 풍선을 고른 뒤 번호가 더 큰 풍선만을 터트릴 수 있습니다.

당신은 어떤 풍선이 최후까지 남을 수 있는지 알아보고 싶습니다. 위에 서술된 조건대로 풍선을 터트리다 보면, 어떤 풍선은 최후까지 남을 수도 있지만, 어떤 풍선은 무슨 수를 쓰더라도 마지막까지 남기는 것이 불가능할 수도 있습니다.

일렬로 나열된 풍선들의 번호가 담긴 배열 a가 주어집니다. 위에 서술된 규칙대로 풍선들을 1개만 남을 때까지 터트렸을 때 최후까지 남기는 것이 가능한 풍선들의 개수를 return 하도록 solution 함수를 완성해주세요.

---

[제한 사항]

• a의 길이는 1 이상 1,000,000 이하입니다.
  • a[i]는 i+1 번째 풍선에 써진 숫자를 의미합니다.
  • a의 모든 수는 -1,000,000,000 이상 1,000,000,000 이하인 정수입니다.
  • a의 모든 수는 서로 다릅니다.

 

 

 

 

 

풀이

---

최후까지 남을 수 있는 방법은 두가지다.

1.  제일 작은 수
2.  제일 작은 수와 둘만 남을 수 있는 수

이렇게 두가지 경우만 최후까지 남을 수 있는 방법이다.

 

첫번째 경우는 찾기 쉽다.

이제 두번째 경우인데.

그림처럼 제일 작은 수를 기준으로 좌우 끝에서 한칸씩 늘려가며 구간에서 가장 작은 수가 늘어난 방향으로 가장 끝에 있으면 된다.

그렇게 되면 나머지 수들은 모두 지울 수 있기 때문이다.

-92

-71

-68

-61

-33

제일 작은 수에서 오른쪽을 기준으로 설명을 하면, -71은 -71 ~ -33 구간에서 최소인 수기 때문에 어떤 수와 묶어도 지워지지 않는다.

 

따라서 -92 와 -71 만 남기 때문에 한번은 작은 수를 지운다는 조건으로 -92를 지우면 최종으로 남을 수 있다.

 

같은 방식으로 하나씩 구간을 줄여가면서 최소인 수를 해보면 알 수 있다.

 

구간에서 최소인 수를 찾는 방식을 좀 복잡하게 SegmentTree 를 이용해서 풀었다.

https://conpulake.tistory.com/52?category=845901 

백준 2357 (최솟값과 최댓값)

 

세그먼트 트리를 이용한 구간에서의 최소 최대는 위 문제에서 풀어본 적 있다.

 

<세그먼트 트리 풀이>

class Solution {
    
    static int[] segmentTree;
        
    public int solution(int[] a) {
        int answer = 1;
        
        int minIndex = 0;
        int min = a[0];
        for(int i = 0 ; i < a.length ; i++){
            if(a[i] < min){
                min = a[i];
                minIndex = i;
            }
        }
        
        segmentTree = new int[(a.length + 1) * 4];
        
        init(a, 1, a.length, 1);
        
        for(int i = minIndex - 1 ; i >= 0 ; i--){
            
            if(findMin(1, a.length, 1, 1, i + 1) == a[i]){
                answer++;
            }
            
        }
        
        for(int i = minIndex + 1 ; i < a.length ; i++){
            if(findMin(1, a.length, 1, i + 1, a.length) == a[i]){
                answer++;
            }
        }
        
        return answer;
    }
    
    static int init(int[] a, int start, int end, int node){
        
        if(start == end){
            return segmentTree[node] = a[start - 1];
        }
        
        int mid = (start + end) / 2;
        
        return segmentTree[node] = Math.min(init(a, start, mid, node * 2), init(a, mid + 1, end, 2 * node + 1));
    }
    
    static int findMin(int start, int end, int node, int first, int last){
        
        if(start > last || end < first){
            return Integer.MAX_VALUE;
        }
        
        else if( start >= first && end <= last){
            return segmentTree[node];
        }
        
        else{
            int mid = (start + end) / 2;
            
            return Math.min(findMin(start, mid, node * 2, first, last), findMin(mid + 1, end, 2 * node + 1, first, last));
        }
    }
}

사실 위와 같이 풀었지만 세그먼트 트리는 이렇게 풀기에 복잡하기도 하고, 구간을 계속 한칸씩 늘려가며 찾아야하는데 시간복잡도가 증가하는 단점이 있기 때문에 간단한 반복문을 통해서도 풀어 보았다.

 

 

<반복문 풀이>

class Solution {
           
    public int solution(int[] a) {
        int answer = 1;
        
        int minIndex = 0;
        int min = a[0];
        for(int i = 0 ; i < a.length ; i++){
            if(a[i] < min){
                min = a[i];
                minIndex = i;
            }
        }
        
        min = Integer.MAX_VALUE;
        for(int i = 0 ; i < minIndex ; i++){
            if(min > a[i]){
                min = a[i];
                answer++;
            }
        }
        
        min = Integer.MAX_VALUE;
        for(int i = a.length - 1; i > minIndex ; i--){
            if(min > a[i]){
                min = a[i];
                answer++;
            }
        }
        
        return answer;
    }
}

 

 

SegmentTree 를 이용한 구간의 최솟값을 구하는 방식은 임의의 구간에서의 최솟값을 구하는 것엔 빠르지만, 이런 문제처럼 하나식 구간을 증가시키면서 최솟값을 찾는 방식에선 느리다.

 

상황에 맞는 방식을 잘 활용하면 좋을 것  같다.

하지만 SegmentTree는 구간에서 최솟값 뿐만아니라 구간합 구간곱 등을 구하는데에도 많이 활용 되기 때문에 한번쯤은 풀어보고 익혀두면 좋을 것 같다.