[Programmers/Python] Queue - 풍선 터트리기

풍선 터트리기

---

문제

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

임의의 인접한 두 풍선을 고른 뒤, 두 풍선 중 하나를 터트립니다.
터진 풍선으로 인해 풍선들 사이에 빈 공간이 생겼다면, 빈 공간이 없도록 풍선들을 중앙으로 밀착시킵니다.
여기서 조건이 있습니다. 인접한 두 풍선 중에서 번호가 더 작은 풍선을 터트리는 행위는 최대 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. 입출력 예 #1

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

   3개의 풍선이 최후까지 남을 수 있으므로, 3을 return 해야 합니다.

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

---

풀이

설계

최초 설계는 다음과 같았다.

최후까지 남기고자 하는 풍선을 기준으로 좌우를 확인, 각각의 minimum 값이 기준 풍선보다 큰지 작은지를 확인한다.

• 양쪽 모두 기준 풍선보다 작다면 해당 풍선은 끝까지 남길 수 없다.
• 양쪽 모두 기준 풍선보다 크다면 해당 풍선은 끝까지 남길 수 있다.
• 양쪽 중 하나가 기준 풍선보다 크고 하나가 기준 풍선보다 작다면 해당 풍선은 끝까지 남길 수 있다.

예시 문제는 통과하였으나 테스트 케이스는 시간 초과로 실패. 알아보니 min() 메서드 자체가 모든 요소들을 순회하며 값을 비교하므로 비교할 요소가 많아질 경우 시간복잡도 문제가 발생할 수 있다고 하였다.

문제를 다시 살펴본 결과 리스트의 길이가 매우 긴 것을 확인하였으므로 일단 a를 리스트가 아닌 큐로 변경하는 것으로 변경. 그리고 시간복잡도를 어떻게 줄일지 고민하는 과정에서 투 포인터 형태로 문제를 푸는 방법에 대해 확인하고 다음과 같이 다시 설계해 보았다.

양 끝단의 값을 각각 left, right로 잡고, 둘 중 더 큰 수의 옆의 수를 middle로 놓고 확인하여 middle이 더 작을 경우 해당 수는 끝까지 남을 수 있으며 동시에 양쪽 중 탐색한 구간의 최솟값이 된다(오른쪽 수와 비교한 것이라면 middle이 right가 된다). 만약 middle이 비교하는 수보다 더 클 경우 해당 수는 끝까지 남을 수 없는 수이다.

따라서 다음과 같이 진행한다.

1. a를 큐로 받고 각각 popleft와 pop로 left와 right를 추출한다.
2. left와 right를 비교하여 더 큰 쪽의 옆에 있는 수를 middle로 받아 비교한다.
3. (left를 기준으로 했을 때) left보다 middle이 작은 경우 middle을 left로 변경하고 2로 되돌아간다. 만약 left보다 middle이 클 경우 cnt를 1 증가시키고 2로 되돌아간다(이러면 a에는 middle이 빠진 상태가 된다).
4. 상기 2~3을 큐가 빌 때까지 반복한다.

코드

from collections import deque

def solution(a):
    queue = deque(a)
    cnt = 0

    left = queue.popleft()
    right = queue.pop()
    while queue:
        if left > right:
            if not a:
                middle = right
            else:
                middle = queue.popleft()

            if left < middle:
                cnt += 1
                continue
            else:
                left = middle
                continue

        else:
            if not queue:
                middle = left
            else:
                middle = queue.pop()

            if right < middle:
                cnt += 1
                continue
            else:
                right = middle
                continue

    return len(a)-cnt

---

분명 코드를 더 깔끔하게 정리할 수도 있을 것 같기는 한데, 일단 지금은 문제를 모두 풀고 나서 무기력한 상태가 되었다. 투 포인터로 접근하는 방법을 이해하고 구현하기까지 은근히 시간이 좀 걸리기도 했고...일단은 여기서 마무리.

참고로 타임 아웃이 났던 코드는 다음과 같다.

def solution(a):
  result = 0
  for i in range(len(a)):
      left_min, right_min = float("inf"), float("inf")
      if i > 0:
          left_min = min(a[0:i])
      if i < len(a)-1:
          right_min = min(a[i+1:])

      if (a[i] < left_min) or (a[i] < right_min):
          result += 1

  print(result)