Merge branch 'main' of https://github.com/YoonYn9915/codingtest_algorithm_study

Author: YoonYn9915

_WeeklyChallenges/W13-[Union-Find]/Assignment_BOJ_1717_집합의표현.py

@@ -4,4 +4,36 @@
 유형: Union-Find, Graph
 '''
 
-# PR 올릴 때 과제 정답 공개 예정
+import sys
+sys.setrecursionlimit(10 ** 6)  # 재귀 깊이 제한 늘리기
+input = sys.stdin.readline
+
+# Union 연산(두 집합을 합치기 위한 함수)
+def union(a, b):
+    p_a = find(a)
+    p_b = find(b)
+
+    if p_a > p_b:  # 값이 더 작은 쪽을 부모로 설정
+        parent[p_a] = p_b
+    else:
+        parent[p_b] = p_a
+
+# Find 연산(같은 집합에 속하는지 확인하기 위한 함수)
+def find(a):
+    if a != parent[a]:
+        parent[a] = find(parent[a])  # 경로 압축
+    return parent[a]
+
+# 연산 수행
+n, m = map(int, input().split())
+parent = [i for i in range(n + 1)]  # 초기: 각 원소가 자기 자신을 부모로 가짐
+
+for _ in range(m):
+    flag, a, b = map(int, input().split())
+    if flag == 0:  # 합집합 연산
+        union(a, b)
+    else:  # 같은 집합 확인 연산
+        if find(a) == find(b):
+            print("YES")
+        else:
+            print("NO")

learntosurf/Dynamic Programming/2025-03-07-[BOJ]-#9095-123더하기.py

@@ -0,0 +1,15 @@
+import sys 
+input = sys.stdin.readline
+
+DP = [0] * 11
+DP[1] = 1
+DP[2] = 2
+DP[3] = 4
+
+for i in range(4, 11):
+    DP[i] = DP[i-1] + DP[i-2] + DP[i-3]
+
+T = int(input())
+for _ in range(T):
+    n = int(input())
+    print(DP[n])

learntosurf/Graph Traversal/2025-03-03-[BOJ]-#1326-폴짝폴짝.py

@@ -0,0 +1,49 @@
+import sys 
+input = sys.stdin.readline
+from collections import deque
+
+N = int(input())
+arr = [0] + list(map(int, input().split())) # 1-based index 사용
+a, b = map(int, input().split())
+
+def bfs(N, arr, a, b):
+    queue = deque([(a, 0)]) # (현재 위치, 점프 횟수)
+    visited = [False] * (N + 1) # 방문 여부 체크 
+    visited[a] = True # 시작점 방문 처리 
+    
+    while queue:
+        pos, jump = queue.popleft()
+        
+        # 목표 지점에 도달하면 점프 횟수 반환 
+        if pos == b:
+            return jump
+        
+        step = arr[pos] # 현재 위치에서 이동할 수 있는 거리
+        if step == 0: 
+            continue # 이동할 수 없는 경우는 다음 탐색을 진행
+        
+        # 양방향 탐색 (오른쪽 방향)
+        next_pos = pos + step  # 첫 번째 점프
+        while next_pos <= N:
+            if not visited[next_pos]:  # 방문하지 않은 곳만 탐색
+                if next_pos == b:  # 목표 지점에 도달하면 즉시 반환
+                    return jump + 1
+                visited[next_pos] = True
+                queue.append((next_pos, jump + 1))  # 점프 횟수 증가
+            next_pos += step  # 다음 배수 위치 탐색
+
+        # 양방향 탐색 (왼쪽 방향)
+        next_pos = pos - step  # 왼쪽 방향 점프
+        while next_pos >= 1:
+            if not visited[next_pos]:  # 방문하지 않은 곳만 탐색
+                if next_pos == b:  # 목표 지점에 도달하면 즉시 반환
+                    return jump + 1
+                visited[next_pos] = True
+                queue.append((next_pos, jump + 1))  # 점프 횟수 증가
+            next_pos -= step  # 다음 배수 위치 탐색
+
+     
+    # 목표 지점에 도달하지 못하면 -1 반환           
+    return -1 
+
+print(bfs(N, arr, a, b))

learntosurf/Graph Traversal/2025-03-03-[BOJ]-#1976-여행가자.py

@@ -0,0 +1,40 @@
+import sys 
+input = sys.stdin.readline
+
+N = int(input().strip()) # 도시의 수 
+M = int(input().strip()) # 여행 계획에 속한 도시의 수
+
+# 유니온 파인드 부모 배열
+parent = [i for i in range(N)]  
+
+# find 연산: 경로 압축을 이용하여 루트 노드 찾기
+def find(x):
+    if parent[x] != x:
+        parent[x] = find(parent[x])
+    return parent[x]
+
+# union 연산: 두 집합을 합치기
+def union(x, y):
+    root_x = find(x)
+    root_y = find(y)
+    if root_x != root_y:
+        parent[root_y] = root_x  # y의 루트를 x로 연결
+
+# 도시 연결 정보 처리
+for i in range(N):
+    row = list(map(int, input().split()))
+    for j in range(N):
+        if row[j] == 1:  # 두 도시가 연결된 경우
+            union(i, j)
+
+# 여행 계획 입력
+plan = list(map(int, input().split()))
+
+# 여행 경로가 같은 집합인지 확인
+root = find(plan[0] - 1)  # 첫 번째 도시의 루트
+for city in plan[1:]:
+    if find(city - 1) != root:
+        print("NO")
+        exit()
+
+print("YES")

learntosurf/Graph Traversal/2025-03-04-[BOJ]-#4963-섬의개수.py

@@ -0,0 +1,34 @@
+import sys
+input = sys.stdin.readline
+from collections import deque
+
+# 8방향 (상, 하, 좌, 우, 대각선 4개)
+dx = [-1, 1, 0, 0, -1, -1, 1, 1]
+dy = [0, 0, -1, 1, -1, 1, -1, 1]
+
+def bfs(x, y, graph, w, h):
+    queue = deque([(x, y)])
+    graph[y][x] = 0  # 방문 처리 (1 → 0 변경)
+
+    while queue: # 큐가 빌 때까지 반복
+        cx, cy = queue.popleft() # 현재 좌표 꺼내기 
+        for i in range(8):  # 8방향 탐색
+            nx, ny = cx + dx[i], cy + dy[i] # 새로운 좌표 계산
+            if 0 <= nx < w and 0 <= ny < h and graph[ny][nx] == 1:
+                graph[ny][nx] = 0  # 방문 처리
+                queue.append((nx, ny)) # 큐에 추가 (다음에 탐색할 곳)
+ 
+while True:
+    w, h = map(int, input().split())
+    if w == 0 and h == 0:
+        break  # 종료 조건
+    island = [list(map(int, input().split())) for _ in range(h)]
+
+    count = 0 # 섬의 개수 
+    for y in range(h):
+        for x in range(w):
+            if island[y][x] == 1:  # 새로운 섬 발견
+                count += 1
+                bfs(x, y, island, w, h) # BFS 실행
+    
+    print(count)

learntosurf/Graph Traversal/2025-03-05-[BOJ]-#27737-버섯농장.py

@@ -0,0 +1,43 @@
+import sys, math
+input = sys.stdin.readline
+from collections import deque
+
+N, M, K = map(int, input().split())
+boards = [list(map(int, input().split())) for _ in range(N)]
+
+def bfs(x, y):
+    queue = deque([(x, y)])
+    boards[x][y] = 1  # 방문 처리
+    areas = 1  # 현재 덩어리 크기
+
+    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]  # 상하좌우 이동
+
+    while queue:
+        x, y = queue.popleft()
+        for dx, dy in directions:
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < N and 0 <= ny < N and boards[nx][ny] == 0:
+                boards[nx][ny] = 1  # 방문 처리
+                queue.append((nx, ny))
+                areas += 1  # 영역 개수 증가
+    return areas
+
+total_nums = 0
+use_seed = False
+
+# 버섯이 자랄 수 있는 칸 찾기
+for i in range(N):
+    for j in range(N):
+        if boards[i][j] == 0:
+            areas = bfs(i, j)  # BFS로 덩어리 크기 계산
+            nums = math.ceil(areas / K)  # 필요한 포자 개수
+            total_nums += nums 
+            use_seed = True  # 포자 사용 가능 여부 확인
+
+if not use_seed:
+    print('IMPOSSIBLE')
+elif total_nums <= M:
+    print('POSSIBLE')
+    print(M - total_nums)  # 남은 포자 개수 출력
+else:
+    print('IMPOSSIBLE')

learntosurf/Graph Traversal/2025-03-06-[BOJ]-#10026-적록색약.py

@@ -0,0 +1,54 @@
+import sys
+input = sys.stdin.readline
+from collections import deque
+
+N = int(input().strip())
+grid = [list(input().strip()) for _ in range(N)]
+
+# 방향 벡터 
+dx = [-1, 1, 0, 0]
+dy = [0, 0, -1, 1]
+
+def bfs(x, y, color, visited, grid):
+    queue = deque([(x, y)])
+    visited[x][y] = True
+    
+    while queue:
+        x, y = queue.popleft()
+        for i in range(4):
+            nx, ny = x + dx[i], y + dy[i]
+            if 0 <= nx < N and 0 <= ny < N and not visited[nx][ny]:
+                if grid[nx][ny] == color:
+                    visited[nx][ny] = True
+                    queue.append((nx, ny))
+
+def count_regions(grid, is_color_blind):
+    visited = [[False] * N for _ in range(N)]
+    count = 0
+
+    for i in range(N):
+        for j in range(N):
+            if not visited[i][j]:  # 방문하지 않은 경우 BFS 탐색 시작
+                count += 1
+                color = grid[i][j]
+
+                # 적록색약 모드라면 R과 G를 동일하게 처리
+                if is_color_blind and color in "RG":
+                    bfs(i, j, "R", visited, grid)
+                else:
+                    bfs(i, j, color, visited, grid)
+    
+    return count
+
+# 적록색약이 아닌 경우
+normal_count = count_regions(grid, is_color_blind=False)
+
+# 적록색약인 경우 (R과 G를 동일하게 처리한 grid 생성)
+for i in range(N):
+    for j in range(N):
+        if grid[i][j] == 'G':
+            grid[i][j] = 'R'
+
+color_blind_count = count_regions(grid, is_color_blind=True)
+
+print(normal_count, color_blind_count)

learntosurf/Graph Traversal/2025-03-08-[BOJ]-#1717-집합의표현.py

@@ -0,0 +1,42 @@
+import sys
+input = sys.stdin.readline
+sys.setrecursionlimit(10**6)
+
+n, m = map(int, input().split())
+parent = [i for i in range(n + 1)]
+rank = [0] * (n + 1)  # 트리 깊이 관리
+
+result = []
+
+def find(x):
+    if parent[x] != x:
+        parent[x] = find(parent[x])  # 경로 압축
+    return parent[x]
+
+def union(x, y):
+    root_x = find(x)
+    root_y = find(y)
+
+    if root_x != root_y:
+        if rank[root_x] > rank[root_y]:  # 더 랭크가 높은 루트로 합침
+            parent[root_y] = root_x
+        elif rank[root_x] < rank[root_y]:
+            parent[root_x] = root_y
+        else:
+            parent[root_y] = root_x
+            rank[root_x] += 1  # 같은 랭크면 한쪽의 랭크 증가
+
+
+for _ in range(m):
+    op, a, b = map(int, input().split())
+    
+    if op == 0:  # 합집합 연산
+        union(a, b)
+    
+    elif op == 1:  # 같은 집합 여부 확인
+        if find(a) == find(b):
+            result.append("YES")
+        else:
+            result.append("NO")
+
+sys.stdout.write("\n".join(result) + "\n")

minjeong/Heap/2025-03-08-[백준]-#11279-최대힙.py

@@ -0,0 +1,17 @@
+import sys
+import heapq
+input = sys.stdin.readline
+
+n = int(input())
+heap = []
+
+while n > 0:
+    num = int(input())
+    n -= 1
+    if num == 0:
+        if len(heap) == 0:
+            print(0)
+            continue
+        print(-heapq.heappop(heap))
+    else:
+        heapq.heappush(heap, -num)

minjeong/Heap/2025-03-08-[백준]-#11286-절댓값힙.py

@@ -0,0 +1,16 @@
+import sys
+import heapq
+input = sys.stdin.readline
+
+n = int(input())
+abs_heap = []
+
+for _ in range(n):
+    num = int(input())
+    if num == 0:
+        if abs_heap:
+            print(heapq.heappop(abs_heap)[1])
+        else:
+            print(0)
+    else:
+        heapq.heappush(abs_heap, (abs(num), num))