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

목차 (클릭시 해당 목차로 이동)

---

 

 

 

문제 설명

일렬로 나열된 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의 모든 수는 서로 다릅니다.

---

입출력 예

a	result
[9,-1,-5]	3
[-16,27,65,-2,58,-92,-71,-68,-61,-33]	6

---

입출력 예 설명

입출력 예 #1

• 첫 번째 풍선(9가 써진 풍선)을 최후까지 남기는 방법은 다음과 같습니다.
  1. [9, -1, -5] 에서 -1, -5가 써진 풍선을 고른 뒤, -1이 써진 풍선(번호가 더 큰 것)을 터트립니다.
  2. [9, -5] 에서 9, -5가 써진 풍선을 고른 뒤, -5가 써진 풍선(번호가 더 작은 것)을 터트립니다.
• 두 번째 풍선(-1이 써진 풍선)을 최후까지 남기는 방법은 다음과 같습니다.
  1. [9, -1, -5] 에서 9, -1이 써진 풍선을 고른 뒤, 9가 써진 풍선(번호가 더 큰 것)을 터트립니다.
  2. [-1, -5] 에서 -1, -5가 써진 풍선을 고른 뒤, -5가 써진 풍선(번호가 더 작은 것)을 터트립니다.
• 세 번째 풍선(-5가 써진 풍선)을 최후까지 남기는 방법은 다음과 같습니다.
  1. [9, -1, -5] 에서 9, -1이 써진 풍선을 고른 뒤, 9가 써진 풍선(번호가 더 큰 것)을 터트립니다.
  2. [-1, -5] 에서 -1, -5가 써진 풍선을 고른 뒤, -1이 써진 풍선(번호가 더 큰 것)을 터트립니다.
• 3개의 풍선이 최후까지 남을 수 있으므로, 3을 return 해야 합니다.

입출력 예 #2

• 최후까지 남을 수 있는 풍선은 -16, -92, -71, -68, -61, -33이 써진 풍선으로 모두 6개입니다.

 

 

 

 

---

 

 

초기접근 아이디어

1. 모든 풍선에 대해 왼쪽과 오른쪽으로 나누어서 최소값을 구한다.
2. 해당 풍선(x)이 왼쪽의 최소값(left_min) 과 오른쪽의 최소값(right_min) 보다 크지만 않으면 해당 풍선은 가장 마지막까지 남을 수 있다.

 

 

 

왼쪽과 오른쪽의 최소값을 구하는 이유

인접한 풍선 두개를 터뜨릴 때 둘중 큰것만 터뜨릴 경우 결국에는 가장 작은 풍선만 남게된다.

 

예시로 아래의 6개 풍선이 있다고 했을때,

58

-69

-33

43

-61

78

어떤 풍선부터 시작해서 터뜨리든, 결국에는 가장 작은 풍선만 남게된다.

그러므로 마지막 남길 풍선을 기준으로 양쪽에서 최소값을 구하는 것이다.

 

 

 

 

해당 풍선이 왼쪽과 오른쪽의 최소값보다 동시에 크지만 않으면 마지막에 남을 수 있는 이유

왼쪽과 오른쪽의 최소값을 구하는 이유에서는 둘 중 큰것만 터뜨릴때만을 고려했다.

하지만 문제에서는 한번에 한해서 작은것을 터뜨릴 수 있다고 되어있다.

 

맨 마지막에 남는 것이 "가능한" 풍선을 고르는 것이므로 가장 마지막까지 남기기 쉬운 경우만 고려해도 되는 것이다.

 

그래서 마지막 남길 풍선이 양쪽에서의 최소값보다 작아야 하는 것이 아닌, 둘중 하나보다도 작으면 마지막 까지 남을 수 있는 것이다.

 

예시)

마지막까지 남았을때

 

1. Last풍선이 양쪽보다 작을때

Left_Min	Last	Right_Min
10	5	9

왼쪽 오른쪽 둘다 터뜨릴 수 있으므로 너무 강력히 가능함

 

 

 

2. Last 풍선이 둘중 하나 보다만 작을때

Left_Min	Last	Right_Min
10	9	5

 

큰것(왼쪽) 터뜨리고, 한번에 한해서 작은것 터뜨릴 수 있기 때문에 작은것(오른쪽) 터뜨리면 가능하다.

 

 

 

3. Last 풍선이 둘보다 클때

Left_Min	Last	Right_Min
5	10	9

한번에 한해 왼쪽 (작은것) 터뜨리고, 남은것은 10, 9 인데 작은것은 더이상 못터뜨리므로 실패

 

 

 

 

 

코드

def solution(a):
    answer = 0

    for i in range(len(a)):
        if i == 0 or i == len(a)-1:
            answer += 1
            continue
        left_min = min(a[:i])
        right_min = min(a[i+1:])
        temp = [left_min, right_min, a[i]]
        if max(temp) != a[i]:
            answer += 1

    return answer

 

 

 

 

보기좋게 시간초과가 났다.

 

 

 

 

시간초과의 원인

 

다시 살펴보니 a의 최대 길이는 1,000,000 이다.

 

내 코드는 

모든 i에 대해 왼쪽과 오른쪽의 최소값을 반복해서 구한다.

 

그래서 시간 복잡도가

O(N^2)이 나온다.

 

n이 100만이므로 파이썬에서는 n^2만 되어도 시간초과이다.

 

 

O(n)으로 최적화하는 방법을 찾아야 한다.

 

 

 

 

 

 

최적화

1. 양쪽에서 최소값을 구하는 연산을 조금이라도 줄여보려고 a[i]보다 큰 풍선은 건너뛰고 구해보기

-> 최악의 경우에 O(n^2) 인것은 똑같음

 

2. 양쪽 끝에서부터 동시에 마지막에 남는 풍선 구해보기

-> "현재"의 양쪽 최소값들과 비교하여 하나보다만 작아도 카운팅 하기

-> 코드를 조금만 수정하면 정확한 O(N) 의 답을 구할 것 같지만 반례를 찾기 힘들어 포기

 

3. i마다 왼쪽의 최소값을 쭉 구하고, 그 다음 i마다 또 오른쪽의 최소값을 쭉 구하고, 그 다음 i마다 왼쪽, 오른쪽 최소값을 비교하며 카운팅

-> O(3N) 이므로 채택

 

 

정답 코드

def solution(a):
    answer = 0

    min_list = [[] for _ in range(len(a))]
    min_value = int(1e9)

    for i in range(len(a)):
        if a[i] < min_value:
            min_list[i].append(a[i])
            min_value = a[i]
        else:
            min_list[i].append(min_value)

    min_value = int(1e9)
    for i in range(len(a)-1, -1, -1):
        if a[i] < min_value:
            min_list[i].append(a[i])
            min_value = a[i]
        else:
            min_list[i].append(min_value)

    for i in range(len(a)):
        if a[i] <= min_list[i][0] or a[i] <= min_list[i][1]:
            answer += 1

    return answer