Merge pull request #135 from AlgorithmStudy-Allumbus/minjeong

Minjeong / 1월 5주차 / 8문제

Author: Mingguriguri

minjeong/Dijkstra/2025-02-01-[백준]-#1238-파티.py

@@ -0,0 +1,59 @@
+import sys
+import heapq
+
+input = sys.stdin.readline
+
+
+def dijkstra(graph, start, n):
+    INF = int(1e9)
+    distance = [INF] * (n + 1)
+    distance[start] = 0  # 시작노드의 거리 0
+    # 최소 힙(우선순위 큐)을 사용하여 (거리, 노드) 튜플을 저장
+    queue = []
+    heapq.heappush(queue, (0, start))  # (거리, 노드)
+
+    while queue:
+        dist, current = heapq.heappop(queue)
+        # 만약 이미 처리된 노드라면 continue
+        if distance[current] < dist:
+            continue
+        # 현재 노드와 인접한 모든 노드를 확인
+        for next_node, cost in graph[current]:
+            # 현재 노드를 거쳐서 인접 노드로 가는 새로운 거리
+            new_dist = dist + cost
+            # 만약 새로 계산한 거리가 기존의 거리보다 짧으면 업데이트하고, 큐에 추가한다.
+            if new_dist < distance[next_node]:
+                distance[next_node] = new_dist
+                heapq.heappush(queue, (new_dist, next_node))
+
+    return distance
+
+
+# 입력: 마을의 수 N, 도로의 수 M, 모이는 마을 X
+N, M, X = map(int, input().split())
+
+graph = [[] for _ in range(N + 1)]
+reverse_graph = [[] for _ in range(N + 1)]
+
+for _ in range(M):
+    u, v, w = map(int, input().split())
+    # u번 마을에서 v번 마을로 가는 도로
+    graph[u].append((v, w))
+    # 역방향 그래프: v번 마을에서 u번 마을로 가는 도로
+    reverse_graph[v].append((u, w))
+
+# 1. X번 마을에서 각 마을까지의 최단 경로 (파티 후 돌아가는 시간)을 구한다.
+distance_from_X = dijkstra(graph, X, N)
+# 2. 각 마을에서 X번 마을까지의 최단 경로 (파티 갈 때 걸리는 시간)을 구한다.
+distance_to_X = dijkstra(reverse_graph, X, N)
+
+# 각 학생의 왕복 시간 중 최댓값을 저장한다.
+max_time = 0
+for i in range(1, N + 1):
+    # 왕복 시간 = (i번 마을에서 X까지 가는 시간) + (X에서 i번 마을까지 가는 시간)
+    round_trip = distance_to_X[i] + distance_from_X[i]
+    # 최댓값 갱신
+    max_time = max(max_time, round_trip)
+
+# 최댓값 출력
+print(max_time)

minjeong/Dijkstra/2025-02-01-[백준]-#4485-녹색옷입은애가젤다지.py

@@ -0,0 +1,52 @@
+import sys
+import heapq
+
+input = sys.stdin.readline
+
+# 오른쪽, 아래, 위, 왼쪽
+dx = [0, 1, -1, 0]
+dy = [1, 0, 0, -1]
+
+# 정답 출력을 위한 테스트 케이스 번호 변수
+cnt = 0
+
+# 첫 번째 테스트 케이스의 동굴 크기
+n = int(input())
+
+while n != 0:
+    cnt += 1
+
+    # 동굴의 각 칸에 있는 도둑루피의 크기를 board에 저장
+    board = [list(map(int, input().split())) for _ in range(n)]
+    heap = []
+    dist = [[1e9] * n for _ in range(n)]
+    dist[0][0] = board[0][0]
+
+    # 시작점 정보를 (비용, y, x) 형태로 힙에 추가
+    heapq.heappush(heap, (board[0][0], 0, 0))
+
+    # 다익스트라 알고리즘
+    while heap:
+        distance, y, x = heapq.heappop(heap)
+
+        # 최소 비용 우선 탐색이므로, 도착점 [n-1][n-1]에 도착하면 바로 출력
+        if y == n - 1 and x == n - 1:
+            print(f"Problem {cnt}: {distance}")
+            n = int(input())
+            break
+
+        # 상하좌우 네 방향에 대해 탐색
+        for i in range(4):
+            ny = y + dy[i]  # 새로운 y 좌표를 계산
+            nx = x + dx[i]  # 새로운 x 좌표를 계산
+
+            # 새로운 좌표가 동굴 내부에 있는지 확인
+            if 0 <= ny < n and 0 <= nx < n:
+                # 인접한 칸까지 이동했을 때의 누적 비용을 계산
+                cost = distance + board[ny][nx]
+
+                # 만약 현재 저장된 비용보다 새로운 비용이 작으면 업데이트
+                if dist[ny][nx] > cost:
+                    dist[ny][nx] = cost
+                    # 새로운 비용과 좌표를 우선순위 큐에 추가
+                    heapq.heappush(heap, (cost, ny, nx))

minjeong/Graph/2025-02-01-[백준]-#1238-파티.py

@@ -0,0 +1,59 @@
+import sys
+import heapq
+
+input = sys.stdin.readline
+
+
+def dijkstra(graph, start, n):
+    INF = int(1e9)
+    distance = [INF] * (n + 1)
+    distance[start] = 0  # 시작노드의 거리 0
+    # 최소 힙(우선순위 큐)을 사용하여 (거리, 노드) 튜플을 저장
+    queue = []
+    heapq.heappush(queue, (0, start))  # (거리, 노드)
+
+    while queue:
+        dist, current = heapq.heappop(queue)
+        # 만약 이미 처리된 노드라면 continue
+        if distance[current] < dist:
+            continue
+        # 현재 노드와 인접한 모든 노드를 확인
+        for next_node, cost in graph[current]:
+            # 현재 노드를 거쳐서 인접 노드로 가는 새로운 거리
+            new_dist = dist + cost
+            # 만약 새로 계산한 거리가 기존의 거리보다 짧으면 업데이트하고, 큐에 추가한다.
+            if new_dist < distance[next_node]:
+                distance[next_node] = new_dist
+                heapq.heappush(queue, (new_dist, next_node))
+
+    return distance
+
+
+# 입력: 마을의 수 N, 도로의 수 M, 모이는 마을 X
+N, M, X = map(int, input().split())
+
+graph = [[] for _ in range(N + 1)]
+reverse_graph = [[] for _ in range(N + 1)]
+
+for _ in range(M):
+    u, v, w = map(int, input().split())
+    # u번 마을에서 v번 마을로 가는 도로
+    graph[u].append((v, w))
+    # 역방향 그래프: v번 마을에서 u번 마을로 가는 도로
+    reverse_graph[v].append((u, w))
+
+# 1. X번 마을에서 각 마을까지의 최단 경로 (파티 후 돌아가는 시간)을 구한다.
+distance_from_X = dijkstra(graph, X, N)
+# 2. 각 마을에서 X번 마을까지의 최단 경로 (파티 갈 때 걸리는 시간)을 구한다.
+distance_to_X = dijkstra(reverse_graph, X, N)
+
+# 각 학생의 왕복 시간 중 최댓값을 저장한다.
+max_time = 0
+for i in range(1, N + 1):
+    # 왕복 시간 = (i번 마을에서 X까지 가는 시간) + (X에서 i번 마을까지 가는 시간)
+    round_trip = distance_to_X[i] + distance_from_X[i]
+    # 최댓값 갱신
+    max_time = max(max_time, round_trip)
+
+# 최댓값 출력
+print(max_time)

minjeong/Graph/2025-02-01-[백준]-#4485-녹색옷입은애가젤다지.py

@@ -0,0 +1,52 @@
+import sys
+import heapq
+
+input = sys.stdin.readline
+
+# 오른쪽, 아래, 위, 왼쪽
+dx = [0, 1, -1, 0]
+dy = [1, 0, 0, -1]
+
+# 정답 출력을 위한 테스트 케이스 번호 변수
+cnt = 0
+
+# 첫 번째 테스트 케이스의 동굴 크기
+n = int(input())
+
+while n != 0:
+    cnt += 1
+
+    # 동굴의 각 칸에 있는 도둑루피의 크기를 board에 저장
+    board = [list(map(int, input().split())) for _ in range(n)]
+    heap = []
+    dist = [[1e9] * n for _ in range(n)]
+    dist[0][0] = board[0][0]
+
+    # 시작점 정보를 (비용, y, x) 형태로 힙에 추가
+    heapq.heappush(heap, (board[0][0], 0, 0))
+
+    # 다익스트라 알고리즘
+    while heap:
+        distance, y, x = heapq.heappop(heap)
+
+        # 최소 비용 우선 탐색이므로, 도착점 [n-1][n-1]에 도착하면 바로 출력
+        if y == n - 1 and x == n - 1:
+            print(f"Problem {cnt}: {distance}")
+            n = int(input())
+            break
+
+        # 상하좌우 네 방향에 대해 탐색
+        for i in range(4):
+            ny = y + dy[i]  # 새로운 y 좌표를 계산
+            nx = x + dx[i]  # 새로운 x 좌표를 계산
+
+            # 새로운 좌표가 동굴 내부에 있는지 확인
+            if 0 <= ny < n and 0 <= nx < n:
+                # 인접한 칸까지 이동했을 때의 누적 비용을 계산
+                cost = distance + board[ny][nx]
+
+                # 만약 현재 저장된 비용보다 새로운 비용이 작으면 업데이트
+                if dist[ny][nx] > cost:
+                    dist[ny][nx] = cost
+                    # 새로운 비용과 좌표를 우선순위 큐에 추가
+                    heapq.heappush(heap, (cost, ny, nx))

minjeong/Greedy/2025-01-29-[백준]-#1439-뒤집기.py

@@ -0,0 +1,26 @@
+import sys
+input = sys.stdin.readline
+
+# 문자열 입력
+S = input().strip()
+
+# 0과 1 덩어리 개수 저장 변수
+count_0 = 0
+count_1 = 0
+
+# 첫 번째 숫자가 0이면 count_0 증가, 1이면 count_1 증가
+if S[0] == '0':
+    count_0 += 1
+else:
+    count_1 += 1
+
+# 연속된 숫자가 바뀔 때마다 덩어리 개수 증가
+for i in range(1, len(S)):
+    if S[i] != S[i - 1]:  # 숫자가 바뀌는 순간
+        if S[i] == '0':
+            count_0 += 1
+        else:
+            count_1 += 1
+
+# 최소한의 뒤집기 횟수 출력
+print(min(count_0, count_1))

minjeong/Greedy/2025-01-29-[백준]-#1946-신입사원.py

@@ -0,0 +1,28 @@
+import sys
+input = sys.stdin.readline
+
+T = int(input())  # 테스트 케이스 수
+
+for _ in range(T):
+    N = int(input())  # 지원자 수
+    new_crew = []
+
+    # 지원자 데이터 입력
+    for _ in range(N):
+        paper_score, interview_score = map(int, input().split())
+        new_crew.append((paper_score, interview_score))
+
+    # 서류 심사 순위 기준 정렬
+    new_crew.sort()
+
+    # 첫 번째 지원자는 무조건 선발
+    answer = 1
+    min_interview_rank = new_crew[0][1]
+
+    # 두 번째 지원자부터 체크
+    for i in range(1, N):
+        if new_crew[i][1] < min_interview_rank:
+            answer += 1
+            min_interview_rank = new_crew[i][1]  # 최소 면접 등수 갱신
+
+    print(answer)

minjeong/Greedy/2025-01-30-[백준]-#10610-30.py

@@ -0,0 +1,12 @@
+import sys
+input = sys.stdin.readline
+
+N = input().strip()
+
+# 0이 없으면 무조건 불가능 / 3의 배수인지 확인 (자리수 합이 3의 배수여야 함)
+if '0' not in N or sum(map(int, N)) % 3 != 0:
+    print(-1)
+    exit()
+
+# 가장 큰 수 출력
+print(''.join(sorted(N, reverse=True)))

minjeong/Greedy/2025-01-30-[백준]-#1202-보석도둑.py

@@ -0,0 +1,40 @@
+import sys
+import heapq
+
+input = sys.stdin.readline
+
+# 입력 받기
+N, K = map(int, input().split())  # N: 보석 개수, K: 가방 개수
+jewelry = []  # (무게, 가격)
+bags = []  # 가방의 최대 무게
+
+for _ in range(N):
+    M, V = map(int, input().split())
+    jewelry.append((M, V))
+
+for _ in range(K):
+    bags.append(int(input()))
+
+# 보석을 무게 기준으로 정렬 (무게가 작은 순)
+jewelry.sort()
+
+# 가방을 무게 기준으로 정렬 (무게가 작은 순)
+bags.sort()
+
+# 우선순위 큐 (최대 힙)
+max_heap = []
+result = 0
+idx = 0
+
+# 가방을 하나씩 처리
+for bag in bags:
+    # 현재 가방이 수용할 수 있는 보석을 모두 추가 (무게 기준 정렬된 상태)
+    while idx < N and jewelry[idx][0] <= bag:
+        heapq.heappush(max_heap, -jewelry[idx][1])  # 최대 힙을 위해 음수 저장
+        idx += 1
+
+    # 가장 가치가 높은 보석을 선택
+    if max_heap:
+        result += -heapq.heappop(max_heap)
+
+print(result)

minjeong/Simulation/2025-01-26-[백준]-#2477-참외밭.py

@@ -0,0 +1,30 @@
+import sys
+input = sys.stdin.readline
+
+# 입력 받기
+K = int(input())  # 1m2에 자라는 참외의 개수
+edges = []
+for _ in range(6):
+    direction, length = map(int, input().split())
+    edges.append((direction, length))
+
+# 큰 직사각형과 작은 직사각형 찾기
+big_area = 0
+small_area = 0
+
+for i in range(6):
+    current = edges[i][1]
+    next_edge = edges[(i + 1) % 6][1]  # 인덱스 순환 처리
+    big_area = max(big_area, current * next_edge)
+
+# 작은 직사각형의 면적 찾기
+for i in range(6):
+		# big_area에 해당하는 인덱스를 찾았다면 그 반대 방향의 면적 찾기
+    if edges[i][1] * edges[(i + 1) % 6][1] == big_area:
+        small_area = edges[(i + 3) % 6][1] * edges[(i + 4) % 6][1]
+        break
+
+# 전체 면적 계산
+total_area = big_area - small_area
+result = K * total_area
+print(result)

minjeong/Simulation/2025-01-31-[백준]-#1475-방번호.py

@@ -0,0 +1,27 @@
+import sys
+input = sys.stdin.readline
+
+# 0~9까지 숫자의 개수를 저장할 딕셔너리 초기화
+dict = { 0: 0, 1: 0, 2: 0, 3: 0, 4: 0,
+         5: 0, 6: 0, 7: 0, 8: 0, 9: 0
+         }
+
+# 방 번호 입력
+room_nums = list(map(int, input().rstrip()))
+
+# 숫자 개수 카운트
+for num in room_nums:
+    if num == 6 or num == 9:
+        if dict[6] <= dict[9]:
+            dict[6] += 1
+        else:
+            dict[9] += 1
+    else:
+        dict[num] += 1
+
+# 가장 많이 필요한 세트 개수 찾기
+answer = 0
+for value in dict.values():
+    answer = max(answer, value)
+
+print(answer)