feat: 5, 6주차 알고리즘 문제 풀이

lily/week_4/boj_10866.py

@@ -0,0 +1,47 @@
+import sys
+
+def is_deq_empty(deq):
+    return len(deq) == 0
+
+readline = sys.stdin.readline
+action_num = int(input())
+deq = []
+for _ in range(action_num):
+    inputs = list(map(str, readline().split()))
+    action = inputs[0]
+    if len(inputs) == 2:
+        digit = int(inputs[1])
+        if action == "push_front":
+            deq.insert(0, digit)
+        else: # "push_back" 
+            deq.append(digit)
+    else:
+        if action == "pop_front":
+            if is_deq_empty(deq):
+                print(-1)
+            else:
+                print(deq[0])
+                deq.pop(0)
+        elif action == "pop_back":
+            if is_deq_empty(deq):
+                print(-1)
+            else:
+                print(deq[-1])
+                deq = deq[:-1]
+        elif action == "size":
+            print(len(deq))
+        elif action == "empty":
+            if is_deq_empty(deq):
+                print(1)
+            else:
+                print(0)
+        elif action == "front":
+            if is_deq_empty(deq):
+                print(-1)
+            else:
+                print(deq[0])
+        else: # back
+            if is_deq_empty(deq):
+                print(-1)
+            else:
+                print(deq[-1])

lily/week_4/boj_15828.py

@@ -0,0 +1,44 @@
+"""
+패킷은 라우터를 여러 번 거침.
+라우터 안의 버퍼: FIFO로 패킷 처리
+라우터가 패킷을 처리하는 속도 < 패킷이 들어오는 속도 => 버퍼에 공간이 생길 때까지 입력받는 패킷은 모두 버려짐
+
+입력
+N: 버퍼 크기
+둘째줄~: 라우터가 처리해야 할 정보
+양의 정수: 해당하는 번호의 패킷
+0은: 라우터가 패킷 하나를 처리
+비어있을 때는 0이 입력 X
+-1은 입력 끝
+
+출력
+라우터에 남아있는 패킷 출력
+비어있으면 empty
+
+O(N)
+10만 * 20만 = 2 * 10^10 => 1초를 벗어남
+"""
+
+from collections import deque
+
+buffer_size = int(input())
+buffer = deque()
+
+while True:
+    pack = int(input())
+    if pack == -1:
+        break
+
+    if pack == 0:
+        buffer.popleft()
+        continue
+
+    if len(buffer) >= buffer_size:
+        continue
+
+    buffer.append(pack)
+
+if len(buffer) > 0:
+    print(*buffer)
+else:
+    print("empty")

lily/week_4/boj_1874.py

@@ -0,0 +1,24 @@
+N = int(input())
+stack = []
+answer = []
+current = 0
+is_seq_possible = True
+for _ in range(N):
+    target_num = int(input()) - 1
+
+    while current <= target_num:
+        stack.append(current)
+        answer.append("+")
+        current += 1
+
+    if len(stack) > 0 and stack[-1] == target_num:
+        stack.pop()
+        answer.append("-")
+    else:
+        is_seq_possible = False
+        break
+
+if is_seq_possible:
+    print('\n'.join(answer))
+else:
+    print("NO")

lily/week_4/boj_4949.py

@@ -0,0 +1,38 @@
+"""
+소괄호, 대괄호 짝 이루는지 확인
+"""
+
+import sys
+
+readline = sys.stdin.readline
+while True:
+    sentence = readline().rstrip()
+    if sentence == ".":
+        break
+
+    brackets = []
+    is_balanced = True
+    for word in sentence:
+        if word not in ["(", ")", "[", "]"]:
+            continue
+
+        if word in ["(", "["]:
+            brackets.append(word)
+        elif word == ")":
+            if len(brackets) == 0 or brackets[-1] != "(":
+                is_balanced = False
+                break
+            brackets.pop()
+        else:
+            if len(brackets) == 0 or brackets[-1] != "[":
+                is_balanced = False
+                break
+            brackets.pop()
+
+    if len(brackets) > 0:
+        is_balanced = False
+
+    if is_balanced:
+        print("yes")
+    else:
+        print("no")

lily/week_4/boj_5397.py

@@ -0,0 +1,27 @@
+import sys
+
+def parsing_password(inputs):
+    cursor_idx = 0
+    password = []
+    for char in inputs:
+        if char == '<':
+            cursor_idx = max(cursor_idx - 1, 0)
+        elif char == '>':
+            cursor_idx = min(cursor_idx + 1, len(password))
+        elif char == '-':
+            cursor_idx = max(cursor_idx - 1, 0)
+            if cursor_idx == 0:
+                continue
+            else:
+                password.pop(cursor_idx)
+        else:
+            password.insert(cursor_idx, char)
+            cursor_idx += 1
+
+    return ''.join(password)
+
+readline = sys.stdin.readline
+T = int(readline())
+for _ in range(T):
+    answer = parsing_password(readline().rstrip())
+    print(answer)

lily/week_4/boj_5430.py

@@ -0,0 +1,59 @@
+"""
+R: 뒤집기
+D: 첫번째 수 버리기 -> 배열이 있는 경우 에러
+
+입력
+첫째줄 테스트 케이스 개수
+둘째줄부터 함수 p 리스트 e.g. RDD
+배열의 길이 n
+배열에 들어있는 수
+
+출력
+각 테스트 케이스에 대해 함수를 수행한 결과를 출력
+에러가 발생한 경우 error 출력
+"""
+
+import sys
+from collections import deque
+
+readline = sys.stdin.readline
+T = int(readline())
+
+for _ in range(T):
+    actions = list(readline().rstrip())
+    nums_len = int(readline())
+    nums_input = readline()
+    if nums_len == 0:
+        if len([action for action in actions if action == "D"]) > 0:
+            print("error")
+        else:
+            print("[]")
+        continue
+
+    deq = deque(list(map(int, nums_input[1:-2].split(","))))
+    is_left = True
+    is_error = False
+    for action in actions:
+        if action == 'R':
+            is_left = not is_left
+        else:
+            if len(deq) == 0:
+                is_error = True
+                break
+
+            if is_left:
+                deq.popleft()
+            else:
+                deq.pop()
+
+    if is_error:
+        print("error")
+    else:
+        if is_left:
+            output = ",".join(list(map(str, deq)))
+            print(f"[{output}]")
+        else:
+            output = ",".join(list(map(str, list(deq)[::-1])))
+            print(f"[{output}]")
+
+

lily/week_5/boj_11779.py

@@ -0,0 +1,49 @@
+"""
+heapq에 넣을 때 해당 노드까지의 리스트도 업데이트
+깊은 복사 + edge 돌아가면서 리스트에 요소 append
+
+출력
+1. 최소 비용
+2. 최소 비용에 속해있는 도시의 수
+3. 최소 비용에 속해있는 도시 (순서대로, 시작과 도착 노드 포함)
+
+디버깅한 것
+시작 노드에서의 dist는 0
+"""
+
+import sys
+import heapq
+import copy
+readline = sys.stdin.readline
+n = int(readline()) # 노드의 수
+m = int(readline()) # 간선의 수
+
+edges = [[] for _ in range(n+1)] # 특정 노드에서 갈 수 있는 간선 정보를 저장하는 (node, cost) 튜플 리스트
+for _ in range(m):
+    s, e, c = map(int, readline().split())
+    edges[s].append((e, c))
+
+start, end = map(int, readline().split()) # 최종 출발점, 도착점
+dist = [float('inf') for _ in range(n+1)]
+path = [[] for _ in range(n+1)] # 시작점에서 해당 노드까지 갔을 때의 경로
+hq = []
+hq.append((0, start))
+dist[start] = 0
+path[start].append(start)
+
+while len(hq) > 0:
+    now_cost, now = heapq.heappop(hq)
+    if dist[now] < now_cost: continue
+
+    for edge in edges[now]:
+        e, c = edge 
+        new_cost = now_cost + c
+        if dist[e] > new_cost:
+            dist[e] = new_cost
+            heapq.heappush(hq, (new_cost, e))
+            path[e] = copy.deepcopy(path[now])
+            path[e].append(e)
+
+print(dist[end])
+print(len(path[end]))
+print(*path[end])

lily/week_5/boj_1238.py

@@ -0,0 +1,61 @@
+"""
+- 문제 요약
+N명의 학생들이 X번 마을에 모임.
+해당 마을에 갔다가, 되돌아 와야 하는데 총 비용이 가장 큰 경우를 찾아라.
+(s -> e, e -> s 따로 구해서 그 합이 가장 큰 값을 찾아야 함)
+
+
+- 입력
+학생 수 N, 간선 수 M, 특정 마을 X
+M개 만큼 s, e, c
+
+- 출력
+갔다 오는데 가장 오래 걸리는 시간
+
+- 각 s 지점에서 X까지 걸리는 시간 각각 계산
+- 특정 마을 X에서 가는 시간도 계산
+
+놓쳤던 부분: 파티가 진행되는 곳에 사는 학생의 dist는 0으로 만들어야 함.
+"""
+
+import sys
+import heapq
+
+def dijkstra(start, X, edges): # 시작 지점부터 끝 지점
+    dist = [float('inf') for _ in range(N+1)]
+    if start == X:
+        dist[X] = 0
+    hq = []
+    heapq.heappush(hq, (0, start))
+
+    while len(hq) > 0:
+        now_cost, now = heapq.heappop(hq)
+        if dist[now] < now_cost:
+            continue
+
+        for edge in edges[now]:
+            e, c = edge
+            new_dist = now_cost + c
+            if dist[e] > new_dist:
+                dist[e] = new_dist
+                heapq.heappush(hq, (new_dist, e))
+
+    return dist
+
+readline = sys.stdin.readline
+N, M, X = map(int, readline().split()) # 학생, 간선, 도착지
+edges = [[] for _ in range(N+1)]
+for _ in range(M):
+    s, e, c = map(int, readline().split())
+    edges[s].append((e, c))
+
+# 도착 지점 -> 각 노드
+dist_from_start = dijkstra(X, X, edges)
+
+# 각 노드 -> 도착 지점
+answer = -1
+for s in range(1, N+1):
+    dist_to_end = dijkstra(s, X, edges)
+    answer = max(answer, dist_from_start[s] + dist_to_end[X])
+
+print(answer)