13주차

Author: limnyn

limnyn/13주차/1202_보석_도둑.py

@@ -0,0 +1,96 @@
+# https://www.acmicpc.net/problem/1202
+
+'''
+보석 도둑
+knabsack문제와 유사한 유형으로 보이는데 
+가방에는 하나의 보석만 넣을 수 있다는 조건으로 인해 knapsack으로는 접근 불가
+
+입력 조건
+    보석 갯수, 가방 갯수 
+        1 <= N , K <= 300,000
+    각 보석의 정보 M_i, V_i
+        0 <= M_i, V_i <= 100,000,000
+    
+보석을 최대한 많이 훔칠 때의 가격의 합
+    1. 그리디? 하게 넣어보기
+        -보석에 대해 가장 적은 크기의 가방부터 그리디하게 채운다.
+        -> 가장 적은 크기 가방에 대해 해당 허용 무게 중 가장 비싼걸 채워넣는다
+        가능한 이유 -> 가방에 "보석 1개" 만 가능하기 때문에
+
+        일단 weight,value를 w, v라고 할 때
+
+        입력받은 w, v에 대해 w를 기준으로 쌍으로 정렬하여 heapq를 만든다
+            입력
+            jewels = []
+            for _ in range(n):
+                w, v = map(int, input().split())
+                heapq.heappush(jewels, (w, v))
+        그리고 가방 크기 또한 크기가 적은 순서대로 입력받는다.
+            backpacks = []
+            for _ in range(k):
+                C_i = int(input())
+                heapq.heappush(backpacks, C_i)
+
+        
+        이제 가방 크기에 대해 채우는 함수를 작성하자
+            1. 전역적으로 사용할 우선순위 큐 하나 선언
+                이 안에는 (가치, 무게) 쌍으로 최대 힙으로 값을 넣는다.
+                v_w_max_pq = []
+            2. 가방의 무게까지 jewels pq에서 하나씩 꺼내 v_w_max_pq에 채워 넣는다
+            
+            3. 다 채운 이후 v_w_max_pq에서 하나를 꺼내서 해당 value를 최대값으로 지정한다.
+                즉 result에 해당 value를 추가한다
+            
+            v_w_max_pq = []
+            result = 0
+            def pick_jewels():
+                global result
+
+                while backpacks:
+                    backpack_limit = heapq.heappop(backpacks)
+                    while jewels and jewels[0][0] <= backpack_limit:
+                        w, v = heapq.heappop(jewels)
+                    if v_w_max_pq: #만약 해당 가방 크기보다 작은 보석들이 존재할 때
+                        heapq.heappush(v_w_max_pq, (-v, w)) #파이썬은 최소힙, 따라서 -붙여 최대힙 구현
+                    result -= heapq.heappop(v_w_max_pq)
+            
+'''
+
+import sys, heapq
+input = sys.stdin.readline
+
+
+def pick_jewels():
+    global result
+
+    while backpacks:
+        backpack_limit = heapq.heappop(backpacks)
+        while jewels and jewels[0][0] <= backpack_limit:
+            w, v = heapq.heappop(jewels)
+            heapq.heappush(v_w_max_pq, (-v, w)) #파이썬은 최소힙, 따라서 -붙여 최대힙 구현
+        if v_w_max_pq:
+            result -= heapq.heappop(v_w_max_pq)[0]
+
+if __name__ == "__main__":
+        
+    n, k = map(int, input().split())
+
+    jewels = []
+    for _ in range(n):
+        w, v = map(int, input().split())
+        heapq.heappush(jewels, (w, v))
+
+    backpacks = []
+    for _ in range(k):
+        C_i = int(input())
+        heapq.heappush(backpacks, C_i)
+
+    
+    v_w_max_pq = []
+    result = 0
+    pick_jewels()
+    print(result)
+
+            
+
+

limnyn/13주차/1238_파티.py

@@ -0,0 +1,105 @@
+# https://www.acmicpc.net/problem/22866
+'''
+1 <= N, L <= 100,000
+
+n^2 불가
+
+문제에서 요구하는 출력
+    건물에서 "거리가 가장 가까운 건물의 번호" 중  "작은 번호"
+    
+    -> 모든 건물을 비교할 필요 없이 "자신보다 큰" 건물 번호를 출력하면 된다
+    
+    이 중 가까운 "작은 번호"를 출력하기
+
+    왼쪽 오른쪽 한번씩 탐색하면서 자신보다 가장 가까운 큰 것을 찾아보자
+    
+    왼쪽에서 오른쪽으로 이동하는 동안
+
+    1. stack[-1], 즉 stack의 top이 현재 빌딩 높이보다 높을 때 까지 pop을 한다.
+    2. 만약 현재 빌딩 높이보다 높은 빌딩이 stack에 존재한다면 
+        결과 리스트에 해당 빌딩의 index를 넣고 현재 빌딩을 stack에 넣는다.    
+        2-1
+            현재 스택에 남아 있는 갯수 = 관측할 수 있는 빌딩의 수
+            따라서 스택의 크기를 계산처리해준다.
+    3. 만액 스텍에 현재 빌딩 높이보다 높은 빌딩이 없다면 결과 리스트에 0을 넣는다.
+
+    왼쪽 탐색        
+    def search_left():
+        stack = []
+        stack.append((buildings[0], 0))
+
+        for i in range(1, n):
+            while stack:
+                if stack[-1][0] <= buildings[i]:
+                    stack.pop()
+                else:
+                    result[i] = stack[-1][1]
+                    building_counts[i] += len(stack)
+                    break
+            stack.append((buildings[i], i))
+            
+    오른쪽 탐색은 위 코드에서 가까운 거리가 오른쪽 탐색이 더 가까울 때 갱신하도록 추가하면 된다.
+        while stack:
+            if stack[-1][0] <= buildings[i]:
+                stack.pop()
+            else:
+                if result[i] == -1 or abs(i - stack[-1][1]) < abs(i - result[i]):
+                    result[i] = stack[-1][1]
+                break
+        building_counts[i] += len(stack)
+        stack.append((buildings[i], i))
+            
+'''
+
+import sys
+input = sys.stdin.readline
+
+def search_left():
+    stack = []
+    stack.append((buildings[0], 0))
+
+    for i in range(1, n):
+        while stack:
+            if stack[-1][0] <= buildings[i]:
+                stack.pop()
+            else:
+                result[i] = stack[-1][1]
+                building_counts[i] += len(stack)
+                break
+        stack.append((buildings[i], i))
+        
+        
+    # print(result)
+
+
+def search_right():
+    stack = []
+    stack.append((buildings[-1], n-1))
+
+    for i in range(n-2, -1, -1):
+        while stack:
+            if stack[-1][0] <= buildings[i]:
+                stack.pop()
+            else:
+                if result[i] == -1 or abs(i - stack[-1][1]) < abs(i - result[i]):
+                    result[i] = stack[-1][1]
+                break
+        building_counts[i] += len(stack)
+        stack.append((buildings[i], i))
+        
+    # print(result)
+
+if __name__ == "__main__":
+    n = int(input())
+    buildings = list(map(int, input().split()))
+    result = [-1]*n
+    building_counts = [0] * n
+    search_left()
+    search_right()
+    
+
+    for idx, building_index in enumerate(result):
+        if building_index == -1:
+            print(0)
+        else:
+            print(f"{building_counts[idx]} {building_index + 1}")