[파이썬 python] 프로그래머스 - 풍선 터트리기

• 풍선 터트리기

문제 설명

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

---

입출력 예

aresult

[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개입니다.

https://programmers.co.kr/learn/courses/30/lessons/68646

코딩테스트 연습 - 풍선 터트리기

 

---

def solution(a):
    answer = 0
    MAX = 1000000001
    MIN = -MAX
    
    left = [0 for i in range(len(a))]
    left_second = [0 for i in range(len(a))]
    left_smallest, left_smallest_second = MAX, MAX
    left[0], left_second[0] = MAX, MAX
    
    for i in range(1,len(a)):
        if a[i-1] < left_smallest:
            left_smallest_second = left_smallest
            left_smallest = a[i-1]
        elif a[i-1] < left_smallest_second:
            left_smallest_second = a[i-1]
        
        left[i], left_second[i] = left_smallest, left_smallest_second
    
    
    right = [0 for i in range(len(a))]
    right_second = [0 for i in range(len(a))]
    right_smallest, right_smallest_second = MAX, MAX
    right[len(a)-1], right_second[len(a)-1] = MAX, MAX
    
    for i in range(len(a)-2, -1, -1):
        if a[i+1] < right_smallest:
            right_smallest_second = right_smallest
            right_smallest = a[i+1]
        elif a[i+1] < right_smallest_second:
            right_smallest_second = a[i+1]
        
        right[i], right_second[i] = right_smallest, right_smallest_second
    
    for i in range(len(a)):
        if a[i] < left[i] and a[i] < right_second[i]:
            answer += 1
        elif a[i] < right[i] and a[i] < left_second[i]:
            answer += 1
        elif a[i] < left[i] or a[i] < right[i]:
            answer += 1

            
    #print(left, left_second)
    #print(right, right_second)
    return answer

 

정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.3MB)
테스트 2 〉	통과 (0.01ms, 10.3MB)
테스트 3 〉	통과 (0.64ms, 10.3MB)
테스트 4 〉	통과 (67.24ms, 17.6MB)
테스트 5 〉	통과 (339.35ms, 48.2MB)
테스트 6 〉	통과 (503.99ms, 65.6MB)
테스트 7 〉	통과 (684.08ms, 86.6MB)
테스트 8 〉	통과 (680.15ms, 86.7MB)
테스트 9 〉	통과 (676.26ms, 86.6MB)
테스트 10 〉	통과 (685.75ms, 86.7MB)
테스트 11 〉	통과 (690.06ms, 86.7MB)
테스트 12 〉	통과 (700.91ms, 86.7MB)
테스트 13 〉	통과 (687.50ms, 86.6MB)
테스트 14 〉	통과 (692.98ms, 86.7MB)
테스트 15 〉	통과 (692.74ms, 86.6MB)

 

후기

 정렬 문제? 인 것 같다. 처음에 이건 어떻게 풀까 싶었던 문제였는데, 하나하나씩 살펴보니 규칙을 찾게 되었다. 시간복잡도가 O(N^2) 이상이면 시간초과가 발생했다.

 

풀이

 * 단순하게 구간을 3개로 나누어 생각한다.

* (현재 숫자 왼쪽 구간의 최솟값 or 2번쨰 최솟값)(현재 숫자)(현재 숫자 오른쪽 구간의 최솟값 or 2번쨰 최솟값).

* 예를 들어 [-16,27,65,-2,58,-92,-71,-68,-61,-33] 에서 -2가 답인지 확인 할때, (최솟값:-16, 2번쨰:27)(-2)(-92,-71) 이다.

* 왜 최솟값을 구하냐면, 최솟값은 번호가 더작은 풍선을 터트린 것을 0번 수행해서이다.

* 2번쨰 최솟값은, 번호가 더 작은 풍선을 터트린 것을 1번만 수행해서이다.

* 왼쪽과 오른쪽 최솟값, 2번째 최솟값을 현재 숫자와 알맞게 비교하면, 현재 숫자를 터트릴 수 있는지 아닌지를 판별할 수 있다.

* 최솟값을 구현하는 것은 왼쪽 배열 1개, 오른쪽 배열 1개로 각각 O(N)의 시간 복잡도를 갖는다.