Merge pull request #140 from learntosurf/main

Learntosurf / 2월 2주차 / 5문제

Author: learntosurf

learntosurf/Graph Traversal/2025-01-27-[BOJ]-#1238-파티.py

@@ -0,0 +1,50 @@
+import sys
+import heapq
+from collections import defaultdict
+input = sys.stdin.readline
+INF = int(1e9)
+
+def dijkstra(start, graph, n):
+    D = [INF] * (n+1)
+    D[start] = 0
+    q = []
+    heapq.heappush(q, (0, start))  # (거리, 노드)
+    
+    while q:
+        dist, now = heapq.heappop(q)  # 최단 거리 노드 꺼내기
+        
+        if D[now] < dist:  # 이미 처리된 노드라면 무시
+            continue
+        
+        for val, next_node in graph[now]:  # 현재 노드와 연결된 노드 탐색
+            cost = dist + val
+            if cost < D[next_node]:  # 더 짧은 경로 발견 시
+                D[next_node] = cost
+                heapq.heappush(q, (cost, next_node))
+                
+    return D
+
+# 입력 처리
+N, M, X = map(int, input().split())
+graph = defaultdict(list)
+reverse_graph = defaultdict(list)
+
+for _ in range(M):
+    start, end, time = map(int, input().split())
+    graph[start].append((time, end))  # 단방향 도로
+    reverse_graph[end].append((time, start))  # X에서 출발하는 경우 대비
+
+# X에서 모든 마을까지의 최단 거리 계산 (X -> 모든 마을)
+to_X = dijkstra(X, graph, N)
+
+# 모든 마을에서 X까지의 최단 거리 계산 (모든 마을 -> X) -> 역방향 그래프 사용
+from_X = dijkstra(X, reverse_graph, N)
+
+# 왕복 시간 계산
+max_time = 0
+for i in range(1, N+1):
+    if i == X:
+        continue  # X에서 출발하는 학생은 제외
+    max_time = max(max_time, to_X[i] + from_X[i])
+
+print(max_time)

learntosurf/Graph Traversal/2025-02-15-[BOJ]-#4485-녹색옷입은애가젤다지?.py

@@ -0,0 +1,45 @@
+import sys
+input = sys.stdin.readline
+import heapq
+
+# 방향 벡터 (상, 하, 좌, 우)
+dx = [-1, 1, 0, 0]
+dy = [0, 0, -1, 1]
+
+def dijkstra(N, cave):
+    INF = float('inf')
+    dist = [[INF] * N for _ in range(N)]
+    
+    # 우선순위 큐 (손실 루피, x, y)
+    pq = []
+    heapq.heappush(pq, (cave[0][0], 0, 0))
+    dist[0][0] = cave[0][0]
+
+    while pq:
+        rupee, x, y = heapq.heappop(pq)
+
+        # 목적지 도착 시 종료
+        if x == N - 1 and y == N - 1:
+            return rupee
+        # 현재 저장된 최소 비용보다 크면 무시
+        if rupee > dist[x][y]:
+            continue
+        for i in range(4):
+            nx, ny = x + dx[i], y + dy[i]
+
+            if 0 <= nx < N and 0 <= ny < N:
+                new_cost = rupee + cave[nx][ny]
+                if new_cost < dist[nx][ny]:
+                    dist[nx][ny] = new_cost
+                    heapq.heappush(pq, (new_cost, nx, ny))
+
+case_num = 1
+
+while True:
+    N = int(input().strip())
+    if N == 0:
+        break
+    cave = [list(map(int, input().split())) for _ in range(N)]
+    result = dijkstra(N, cave)
+    print(f"Problem {case_num}: {result}")
+    case_num += 1  

learntosurf/Greedy/2025-02-03-[BOJ]-#1202-보석도둑.py

@@ -0,0 +1,26 @@
+import sys 
+input = sys.stdin.readline
+import heapq
+
+N, K = map(int, input().split()) # 보석 개수, 가방 개수
+jewels = [tuple(map(int, input().split())) for _ in range(N)] # (보석 무게, 보석 가격)
+bags = [int(input()) for _ in range(K)] # 가방 무게 
+
+# 오름차순 정렬 
+jewels.sort()
+bags.sort()
+
+max_heap = []
+total_v = 0
+j = 0
+
+for bag in bags: 
+    # 현재 가방에 담을 수 있는 보석을 힙에 추가  
+    while j < N and jewels[j][0] <= bag:
+        heapq.heappush(max_heap, -jewels[j][1]) # 가격을 음수로 저장
+        j +=1
+    # 현재 가방에서 가장 비싼 보석을 선택 
+    if max_heap:
+        total_v += -heapq.heappop(max_heap) # 음수로 저장한 값 되돌리기 
+
+print(total_v)

learntosurf/Implementation/2025-02-10-[BOJ]-#20057-마법사상어와토네이도.py

@@ -0,0 +1,81 @@
+import sys 
+input = sys.stdin.readline
+
+N = int(input())
+A = [list(map(int, input().split())) for _ in range(N)] # NxN 격자 
+
+# 방향: 좌 -> 하 -> 우 -> 상 
+directions = [(-1, 0), (0, 1), (1, 0), (0, -1)]
+
+# 모래 이동 비율 (왼쪽으로 이동할 때 기준)
+sand_ratio = [
+    (-1, 1, 0.01), (1, 1, 0.01),
+    (-1, 0, 0.07), (1, 0, 0.07),
+    (-2, 0, 0.02), (2, 0, 0.02),
+    (-1, -1, 0.10), (1, -1, 0.10),
+    (0, -2, 0.05),
+    (0, -1, 'alpha') # a: 남은 모래를 놓을 위치 
+]
+
+out_sand = 0 # 격자 밖으로 나간 모래의 양
+
+# 주어진 방향에 따라 (dx, dy)를 회전
+def rotate_dir(dx, dy, dir):
+    for _ in range(dir):
+        dx, dy = dy, -dx # 90도 회전
+    return dx, dy
+
+# 모래를 현재 위치 (x,y)에서 dir 방향으로 퍼뜨림 
+def spread_sand(x, y, dir):
+    global out_sand
+    total_sand = A[x][y] # 현재 위치의 모래 양 
+    spread_sum = 0 # 흩날린 모래 총합
+    A[x][y] = 0 # 현재 위치 모래를 먼저 없애줌 
+    
+    for dx, dy, ratio in sand_ratio:
+        if ratio == 'alpha': # a 위치일 때 처리 
+            continue
+        # 현재 방향(dir)에 맞게 회전 적용 
+        nx, ny = rotate_dir(dx, dy, dir) # 회전 적용
+        nx, ny = x + dx, y + dy # 이동 좌표 계산 
+        sand = int(total_sand * ratio) # 소수점 버림 
+        
+        if 0 <= nx < N and 0 <= ny < N:
+            A[nx][ny] += sand # 격자 내에 있으면 더하기
+        else:
+            out_sand += sand # 격자 밖이면 밖으로 나간 모래에 추가 
+        
+        spread_sum += sand # 흩날린 모래 총합 증가 
+    
+    # 남은 모래를 a 위치에 배치 
+    dx, dy = rotate_dir(sand_ratio[-1][0], sand_ratio[-1][1], dir) 
+    alpha_x, alpha_y = x + dx, y + dy
+    remaining_sand = total_sand - spread_sum # 남은 모래 계산 
+    
+    if 0 <= alpha_x < N and 0 <= alpha_y < N:
+        A[alpha_x][alpha_y] += remaining_sand 
+    else: 
+        out_sand += remaining_sand # 격자 밖이면 밖으로 나간 모래에 추가 
+     
+     
+x, y = N // 2, N // 2 # 시작위치 (중앙)
+steps = 1 # 이동거리 
+dir = 0 # 방향 인덱스 (0:좌, 1:하, 2:우, 3:상)
+
+while (x, y) != (0, 0): # (1,1)까지 이동
+    for _ in range(2): # 같은 step 크기로 두 번 이동 (좌->하, 우->상)
+        for _ in range(steps):
+            x += directions[dir][0]
+            y += directions[dir][1]
+            
+            spread_sand(x, y, dir) # 모래 퍼뜨리기 
+            
+            if x == 0 and y == 0: # (1,1) 도착하면 종료 
+                break
+    
+        dir = (dir + 1) % 4 # 방향 변경 
+    
+    steps += 1 # step 크기 중가 
+
+print(out_sand)
+    

learntosurf/Implementation/2025-02-15-[BOJ]-#19638-센티와마법의뿅망치.py

@@ -0,0 +1,36 @@
+import sys
+input = sys.stdin.readline
+import heapq
+
+N, Hcenti, T = map(int, input().split())
+giants = [-int(input().strip()) for _ in range(N)]  # 최대 힙을 위해 음수 변환
+
+# 최대 힙 생성
+heapq.heapify(giants)
+used_hammer = 0  # 사용한 뿅망치 횟수
+
+# 마법의 뿅망치를 사용
+for _ in range(T):
+    tallest = -heapq.heappop(giants)  # 가장 큰 거인 추출
+    
+    if tallest < Hcenti:  # 센티보다 작아졌다면 종료
+        heapq.heappush(giants, -tallest)
+        break
+
+    if tallest == 1:  # 키가 1이면 줄일 수 없으므로 다시 넣고 종료
+        heapq.heappush(giants, -tallest)
+        break
+
+    new_height = tallest // 2  # 키 줄이기
+    heapq.heappush(giants, -new_height)  # 줄인 값 다시 삽입
+    used_hammer += 1  # 사용 횟수 증가
+
+# 가장 키가 큰 거인 확인 (힙이 비었으면 0)
+tallest_remaining = -heapq.heappop(giants) if giants else 0
+
+if tallest_remaining < Hcenti:
+    print("YES")
+    print(used_hammer)
+else:
+    print("NO")
+    print(tallest_remaining)