Merge pull request #85 from 24-Algorithm/minjeong

Minjeong / 11월 2주차 / 9문제

Author: Mingguriguri

minjeong/DFSBFS/2024-11-05-[백준]-#2644-촌수계산(BFS).py

@@ -0,0 +1,37 @@
+# 2644-촌수계산. BFS 풀이
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+n = int(input())                    # 전체 사람 수
+a, b = map(int, input().split())    # 촌수 계산할 두 사람의 번호
+m = int(input())                    # 부모-자식 관계의 개수
+graph = [[] for _ in range(n + 1)]  # 그래프 초기화
+visited = [False for _ in range(n + 1)]  # 방문 여부 초기화
+for _ in range(m):
+    x, y = map(int, input().split())
+    graph[x].append(y)
+    graph[y].append(x)
+
+
+def bfs(start, end):
+    queue = deque([(start, 0)]) # (노드, 거리) 형태로 초기화
+    visited[start] = True       # 시작 노드 방문 표시
+
+    while queue:
+        v, dist = queue.popleft()
+
+        # 목표 노드에 도달 시 거리 반환
+        if v == end:
+            return dist
+
+        for neighbor in graph[v]:
+            if not visited[neighbor]:
+                visited[neighbor] = True
+                queue.append((neighbor, dist + 1))  # 거리 1 증가하여 큐에 추가
+
+    return -1  # 연결되지 않았을 경우 -1 반환
+
+
+print(bfs(a, b))

minjeong/DFSBFS/2024-11-05-[백준]-#2644-촌수계산(DFS).py

@@ -0,0 +1,36 @@
+# 2644-촌수계산. DFS(백트래킹) 풀이
+import sys
+
+input = sys.stdin.readline
+
+n = int(input())                    # 전체 사람 수
+a, b = map(int, input().split())    # 촌수 계산해야 하는 두 사람의 번호
+m = int(input())                    # 부모 자식들간의 관계의 개수
+graph = [[] for _ in range(n + 1)]  # 그래프
+visited = [False for _ in range(n + 1)]  # 방문여부
+for _ in range(m):
+    x, y = map(int, input().split())
+    # 그래프 연결
+    graph[x].append(y)
+    graph[y].append(x)
+
+result = -1  # 기본값은 -1로 설정하여 찾지 못한 경우에 대비
+
+def backtracking(v, level):
+    global result
+    # 재귀함수 마치는 조건: a,b 촌수를 계산이 되었을 때
+    if v == b:
+        result = level
+        return
+
+    # 탐색
+    for i in graph[v]:
+        if not visited[i]:
+            visited[i] = True
+            backtracking(i, level + 1)  # 자식 노드 방문 level + 1을 넘겨줌으로써 촌수 계산
+            visited[i] = False          # 방문했다면 부모노드 다시 방문 기록 지움
+
+
+visited[a] = True # 초기 노드 방문 체크
+backtracking(a, 0)
+print(result)

minjeong/DFSBFS/2024-11-06-[백준]-#18352-특정거리의도시찾기.py

@@ -0,0 +1,43 @@
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+
+def bfs(start):
+    queue = deque([start])
+    answer = []  # 시작 도시에서 최단거리 k인 모든 도시 번호를 저장할 리스트
+    visited[start] = 0  # 시작 노드 방문 표시 (시작노드는 거리 0)
+
+    while queue:
+        current = queue.popleft()
+
+        # 현재 노드와 연결된 노드 탐색
+        for node in graph[current]:
+            if visited[node] == -1:  # 아직 방문하지 않았다면 방문 처리하고 큐에 추가
+                visited[node] = visited[current] + 1  # 현재 노드의 거리 + 1
+                queue.append(node)
+
+                # 연결된 노드의 거리가 k와 같을 경우 answer에 추가
+                if visited[node] == k:
+                    answer.append(node)
+    return answer
+
+
+# 도시의 개수 n, 도로의 개수 m, 거리 정보 k, 출발도시 번호 x
+n, m, k, x = map(int, input().split())
+graph = [[] for _ in range(n + 1)]  # 그래프
+visited = [-1] * (n + 1)
+
+# 그래프 연결
+for _ in range(m):
+    a, b = map(int, input().split())
+    graph[a].append(b)
+
+# 출발도시 번호 x부터 BFS 탐색
+answer = bfs(x)
+if answer:
+    for ans in sorted(answer):
+        print(ans)
+else:
+    print(-1)  # 최단거리 k인 도시가 하나도 존재하지 않으면 -1 출력

minjeong/DFSBFS/2024-11-06-[백준]-#7562-나이트의이동.py

@@ -0,0 +1,51 @@
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+# 1. 나이트가 이동할 수 있는 8가지 방향을 정의
+directions = [(0, 0), (-1, -2), (1, -2), (-2, -1), (2, -1), (-1, 2), (1, 2), (-2, 1), (2, 1)]
+
+
+# 5. BFS 탐색 함수 정의
+def bfs(start_x, start_y):
+    # 시작 노드를 큐에 추가하고 해당 위치의 값을 0으로 설정
+    queue = deque([(start_x, start_y)])
+    chess_map[start_x][start_y] = 0
+
+    # 큐가 빌 때까지 탐색
+    while queue:
+        x, y = queue.popleft()
+
+        # 현재 위치에서 모든 방향으로 이동 시도
+        for dx, dy in directions:
+            nx, ny = x + dx, y + dy
+
+            # 5.2.1 체스판의 범위를 넘어가지 않는지 확인
+            if 0 <= nx < l and 0 <= ny < l:
+                # 아직 방문하지 않은 위치라면
+                if chess_map[nx][ny] == -1:
+                    # 현재 위치에서 1 이동한 값으로 갱신하고 큐에 추가
+                    chess_map[nx][ny] = chess_map[x][y] + 1
+                    queue.append((nx, ny))
+
+                # 5.2.2. 목표 지점에 도달한 경우, 이동 횟수 반환
+                if nx == fin_x and ny == fin_y:
+                    return chess_map[nx][ny]
+
+    return -1  # 목표 지점에 도달하지 못한 경우
+
+
+# 2. 테스트 케이스 개수 입력
+t = int(input())
+for _ in range(t):
+    # 3. 체스판의 크기, 시작 위치, 목표 위치 입력
+    l = int(input())  # 체스판의 한 변의 길이 l
+    cur_x, cur_y = map(int, input().split())  # 시작 위치
+    fin_x, fin_y = map(int, input().split())  # 목표 위치
+
+    # 4. 체스판 초기화 (-1로 초기화하여 미방문 표시)
+    chess_map = [[-1] * l for _ in range(l)]
+
+    # 6. BFS 탐색을 통해 결과 출력
+    print(bfs(cur_x, cur_y))

minjeong/DFSBFS/2024-11-07-[백준]-#25195-Yes_or_yes.py

@@ -0,0 +1,43 @@
+import sys
+sys.setrecursionlimit(10**6) # 재귀 한도
+
+input = sys.stdin.readline
+
+def dfs(current):
+    if not visited[current]:
+        if current not in gomgom: # 해당 노드에 팬클럽 곰곰이가 없다면, 방문 표시
+            visited[current] = True
+        else:
+            # 시작부터 곰곰이 있기 때문에 True가 나올 수가 없기에 False 반환
+            return False
+
+    if not graph[current]:  # 더이상 탐색할 노드가 없다면, 팬클럽을 만나지 않아도 되기 때문에 True 반환
+        return True
+
+    for node in graph[current]:
+        if not visited[node]:
+            visited[node] = True
+            if node not in gomgom: # 인접 노드에 팬클럽이 없다면, 재귀호출
+                if dfs(node): # 팬클럽을 만나지 않고 도착할 수 있는 경우 True 반환
+                    return True
+            visited[node] = False # 다른 경로를 탐색하기 위해 방문취소
+
+    return False
+
+# 정점의 개수 n, 간선의 개수 m
+n, m = map(int, input().split())
+graph = [[] for _ in range(n+1)]
+visited = [False] * (n+1)
+for _ in range(m):
+    u, v = map(int, input().split())
+    graph[u].append(v) # u에서 v로의 단방향 간선 추가
+
+# 팬클럽 곰곰이 정보
+s = int(input())                            # 곰곰이가가 존재하는 정점의 개수 s
+gomgom = list(map(int, input().split()))    # 공곰이가 존재하는 정점의 번호 목록
+
+# 1번 정점에서 dfs 탐색 시작
+if dfs(1):  # 팬클럽 곰곰이를 만나지 않고 이동할 수 있는 경우
+    print("yes")
+else: # 어떻게 이동하는 곰곰이를 만나게 되는 경우
+    print("Yes")

minjeong/DFSBFS/2024-11-07-[백준]-#2573-빙산.py

@@ -0,0 +1,74 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+# 이차원 배열의 행과 열 개수 입력
+n, m = map(int, input().split())
+
+# 빙산 높이 정보를 저장할 2차원 배열 생성
+iceberg = [list(map(int, input().split())) for _ in range(n)]
+
+# 빙산 높이 감소를 계산하는 함수
+def get_iceberg_height(iceberg):
+    # 감소된 빙산 높이를 저장할 새로운 배열 초기화
+    new_height = [[0] * m for _ in range(n)]
+    for i in range(n):
+        for j in range(m):
+            if iceberg[i][j] > 0:  # 빙산이 있는 칸만 처리
+                water_count = 0  # 인접한 바다 칸 개수 초기화
+
+                # 상하좌우 네 방향 탐색
+                for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                    ni, nj = i + dx, j + dy
+                    if 0 <= ni < n and 0 <= nj < m and iceberg[ni][nj] == 0:
+                        water_count += 1
+
+                # 바다에 접한 개수만큼 빙산 높이를 감소시키며 최소 0으로 유지
+                new_height[i][j] = max(iceberg[i][j] - water_count, 0)
+    return new_height
+
+# BFS를 통해 빙산 덩어리 수를 계산하는 함수
+def count_icebergs(iceberg):
+    visited = [[False] * m for _ in range(n)]  # 방문 여부를 기록할 배열 초기화
+    iceberg_count = 0  # 빙산 덩어리 수 초기화
+
+    for i in range(n):
+        for j in range(m):
+            # 빙산이 있고 아직 방문하지 않은 경우 새로운 덩어리로 간주
+            if iceberg[i][j] > 0 and not visited[i][j]:
+                iceberg_count += 1
+                # BFS로 연결된 빙산을 모두 방문 처리
+                queue = deque([(i, j)])
+                visited[i][j] = True
+                while queue:
+                    x, y = queue.popleft()
+                    for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                        nx, ny = x + dx, y + dy
+                        # 빙산이 연결된 인접 노드를 방문 처리
+                        if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny] and iceberg[nx][ny] > 0:
+                            visited[nx][ny] = True
+                            queue.append((nx, ny))
+    return iceberg_count
+
+# 연도(시간) 초기화
+year = 0
+
+# 빙산이 분리될 때까지 반복
+while True:
+    year += 1
+
+    # 빙산 높이 감소 계산 및 업데이트
+    iceberg = get_iceberg_height(iceberg)
+
+    # 현재 빙산 덩어리 수 계산
+    mountain = count_icebergs(iceberg)
+
+    # 빙산 덩어리가 2개 이상으로 분리된 경우
+    if mountain >= 2:
+        print(year)
+        exit(0)
+
+    # 빙산이 모두 녹아 덩어리가 없는 경우
+    if mountain == 0:
+        print(0)
+        exit(0)

minjeong/DFSBFS/2024-11-08-[백준]-#7569-토마토.py

@@ -0,0 +1,65 @@
+import sys
+from collections import deque
+
+input = sys.stdin.readline
+
+# 상자의 가로 m, 세로 n, 높이 h
+m, n, h = map(int, input().split())
+tomatoes = []
+
+for _ in range(h):
+    layer = [list(map(int, input().split())) for _ in range(n)]
+    tomatoes.append(layer)
+
+
+# 상하좌우앞뒤 방향
+directions = [(0, 0, 1), (0, 0, -1), (0, -1, 0), (0, 1, 0), (1, 0, 0), (-1, 0, 0)] # 상하좌우앞뒤
+
+def bfs():
+    queue = deque() # (층, 행, 열, 일수)
+
+    # 초기 익은 토마토 위치 큐에 추가
+    for z in range(h):
+        for x in range(n):
+            for y in range(m):
+                if tomatoes[z][x][y] == 1:
+                    queue.append((z, x, y, 0))  # (층, 행, 열, 일수)
+
+    max_day = 0  # 익는 데 걸린 최대 일수 추적
+
+    while queue:
+        z, x, y, day = queue.popleft()
+        max_day = max(max_day, day)  # 가장 오래 걸린 일수 갱신
+
+        for dz, dx, dy in directions:
+            nz, nx, ny = z + dz, x + dx, y + dy
+            if 0 <= nz < h and 0 <= nx < n and 0 <= ny < m:
+                if tomatoes[nz][nx][ny] == 0:  # 익지 않은 토마토일 때
+                    tomatoes[nz][nx][ny] = 1
+                    queue.append((nz, nx, ny, day + 1))  # 익는 데 하루 추가
+
+
+    return max_day
+
+def all_ripe():
+    # 모든 토마토가 익었는지 확인
+    for i in range(h):
+        for j in range(n):
+            for k in range(m):
+                if tomatoes[i][j][k] == 0:
+                    return False
+    return True
+
+# 초기 상태 확인
+if all_ripe():
+    print(0)
+    exit(0)
+else:
+    days = bfs()
+
+    # 모든 토마토가 익었는지 다시 확인
+    if all_ripe():
+        print(days)
+    else:
+        print(-1)
+

minjeong/DynamicProgramming/2024-11-10-[백준]-#14916-거스름돈(DP).py

@@ -0,0 +1,13 @@
+import sys
+input = sys.stdin.readline
+
+n = int(input()) # 거스름돈 액수
+
+dp = [0] * (n+1)
+#           0  1 2  3 4 5 6 7 8 9
+dp[:10] = [-1,-1,1,-1,2,1,3,2,4,3]
+
+for i in range(10,n+1):
+    dp[i] = dp[i-5] + 1
+
+print(dp[n])