11-janghw0126

janghw0126/BFS/숨바꼭질.py

@@ -0,0 +1,33 @@
+import sys
+from collections import deque
+
+def bfs_find_min_time(start, target, max_pos):
+    # BFS를 위한 큐를 생성함
+    queue = deque([start])
+
+    while queue:
+        current_pos = queue.popleft()
+
+        # 현재 위치가 목표 위치와 같으면, 거리 배열에서 시간을 출력함
+        if current_pos == target:
+            print(time_taken[current_pos])
+            return
+
+        # 반복문을 통해 이동할 수 있는 세 가지 경우를 고려함
+        for next_pos in (current_pos - 1, current_pos + 1, current_pos * 2):
+            # 다음 위치가 범위 내에 있고 아직 방문하지 않은 위치일 경우
+            if 0 <= next_pos <= max_pos and time_taken[next_pos] == 0:
+                # 현재 위치에서 1초가 추가된 시간을 저장함
+                time_taken[next_pos] = time_taken[current_pos] + 1
+                # 다음 위치를 큐에 추가함
+                queue.append(next_pos)
+
+# 초기 설정을 함 (문제에서 주어진 최대 위치 값을 뜻함)
+MAX_POSITION = 100000
+# 수빈이의 시작 위치 n과 동생의 위치 k를 입력받음
+n, k = map(int, sys.stdin.readline().split())
+# 각 위치까지 걸리는 시간을 기록하는 배열을 초기화함
+time_taken = [0] * (MAX_POSITION + 1) 
+
+# BFS를 실행함
+bfs_find_min_time(n, k, MAX_POSITION)

janghw0126/DFS/양과 늑대.py

@@ -0,0 +1,40 @@
+# 전역 변수로 최대 양의 수를 저장
+max_count = 0
+
+def solution(info, edges):
+    # 각 노드의 자식 노드를 저장할 리스트 초기화
+    child = [[] for _ in range(len(info))]
+
+    # edges에 따라 부모-자식 관계를 설정
+    for p, c in edges:
+        child[p].append(c)
+
+    # 깊이 우선 탐색(DFS)을 수행하는 재귀 함수 정의
+    def dfs(node, sheep, wolf, next_nodes):
+        global max_count
+
+        # 늑대 수가 양 수보다 많아지면 탐색 중지
+        if wolf >= sheep:
+            return
+
+        # 최대 양의 수를 갱신
+        max_count = max(max_count, sheep)
+
+        # 현재 노드의 자식 노드들을 탐색 가능 노드 리스트에 추가
+        next_nodes.extend(child[node])
+
+        # 다음으로 이동할 수 있는 노드들을 순회
+        for next_node in next_nodes:
+            # 다음 노드가 현재 위치가 아닌 경우에만 이동
+            new_next_nodes = [n for n in next_nodes if n != next_node]
+            # 다음 노드에 늑대가 있는 경우
+            if info[next_node]:
+                dfs(next_node, sheep, wolf + 1, new_next_nodes)
+            # 다음 노드에 양이 있는 경우
+            else:
+                dfs(next_node, sheep + 1, wolf, new_next_nodes)
+
+    # 루트 노드(0번)에서 DFS 시작 (처음에 양 1마리가 있음)
+    dfs(0, 1, 0, child[0])
+
+    return max_count

janghw0126/README.md

@@ -42,4 +42,9 @@
 | 4차시 | 2024.7.28 | 분할 정복 |  <a href= "https://www.acmicpc.net/problem/1074">Z</a> |[#135](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/135) |
 | 5차시 | 2024.7.31 | 위상정렬 |  <a href= "https://www.acmicpc.net/problem/2056">작업</a> |[#138](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/138) |
 | 6차시 | 2024.8.3 | BFS |  <a href= "https://www.acmicpc.net/problem/14940">쉬운 최단거리</a> |[#140](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/140) |
----
+| 7차시 | 2024.8.8 | DFS |  <a href= "https://school.programmers.co.kr/learn/courses/30/lessons/92343">양과 늑대</a> |[#145](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/145) |
+| 8차시 | 2024.8.19 | 최소 힙 |  <a href= "https://www.acmicpc.net/problem/2075">N번째 큰 수</a> |[#145](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/147) |
+| 9차시 | 2024.8.25 | BFS |  <a href= "https://www.acmicpc.net/problem/1697">숨바꼭질</a> |[#149](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/149) |
+| 10차시 | 2024.9.9 | 위상정렬 |  <a href= "https://www.acmicpc.net/problem/2252">줄 세우기</a> |[#158](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/158) |
+| 11차시 | 2024.9.17 | 우선순위 큐 |  <a href= "https://www.acmicpc.net/problem/7662">이중 우선순위 큐</a> |[#160](https://github.com/AlgoLeadMe/AlgoLeadMe-4/pull/160) |
+---

janghw0126/위상정렬/줄 세우기.py

@@ -0,0 +1,39 @@
+import sys
+from collections import deque
+
+n, m = map(int, sys.stdin.readline().split())
+
+# 그래프와 진입 차수 리스트를 초기화함
+graph = [[] for _ in range(n + 1)]
+deg = [0] * (n + 1)
+q = deque()
+res = []
+
+# 비교 관계 입력과 그래프를 구성함
+for _ in range(m):
+    u, v = map(int, sys.stdin.readline().rstrip().split())
+    # u가 v 앞에 서야 함
+    graph[u].append(v)
+    # v의 진입 차수를 증가시킴
+    deg[v] += 1
+
+# 진입 차수가 0인 노드 큐에 삽입함
+for i in range(1, n + 1):
+    if deg[i] == 0:
+        q.append(i)
+
+# 위상 정렬을 시작함
+while q:
+    # 진입 차수가 0인 노드를 큐에서 꺼냄
+    cur = q.popleft()
+    # 결과 리스트에 추가함
+    res.append(cur) 
+
+    # 현재 노드 뒤에 서야 하는 노드들의 진입 차수를 감소시킴
+    for next_node in graph[cur]:
+        deg[next_node] -= 1
+        # 진입 차수가 0이 되면 큐에 추가함
+        if deg[next_node] == 0:
+            q.append(next_node)
+
+print(*res)

janghw0126/힙/N번째 큰 수.py

@@ -0,0 +1,24 @@
+import sys, heapq
+
+input = sys.stdin.readline
+# 행렬의 크기를 입력받음
+N = int(input())  
+min_heap = []
+
+for _ in range(N):
+    row = list(map(int, input().split()))
+
+    # 첫 번째 입력 시 힙을 초기화 함
+    if not min_heap:
+        for num in row:
+            heapq.heappush(min_heap, num)
+    else:
+        for num in row:
+            # 힙의 최솟값보다 현재 숫자가 크다면
+            if min_heap[0] < num: 
+                heapq.heappush(min_heap, num)
+                # 힙의 크기를 N으로 유지함
+                heapq.heappop(min_heap)  
+
+# N번째 큰 수를 출력함
+print(min_heap[0])

janghw0126/힙/이중 우선순위 큐.py

@@ -0,0 +1,42 @@
+import sys
+import heapq
+
+def solve():
+    input = sys.stdin.readline
+    T = int(input())
+
+    for _ in range(T):
+        min_heap = []   # 최소 힙
+        max_heap = []   # 최대 힙 (음수로 변환하여 저장)
+        count = int(input())  # 명령어 수
+        status = [1] * count  # 작업 상태 추적 (1: 유효, 0: 삭제됨)
+
+        for i in range(count):
+            command, value = input().split()
+            value = int(value)
+
+            if command == "I":  # 삽입 연산
+                heapq.heappush(min_heap, (value, i))
+                heapq.heappush(max_heap, (-value, i))
+            elif command == "D":  # 삭제 연산
+                if value == -1:  # 최소값 삭제
+                    if min_heap:
+                        status[heapq.heappop(min_heap)[1]] = 0
+                elif value == 1:  # 최대값 삭제
+                    if max_heap:
+                        status[heapq.heappop(max_heap)[1]] = 0
+
+            # 유효하지 않은 값 제거
+            while min_heap and status[min_heap[0][1]] == 0:
+                heapq.heappop(min_heap)
+            while max_heap and status[max_heap[0][1]] == 0:
+                heapq.heappop(max_heap)
+
+        # 결과 출력
+        if not min_heap or not max_heap:
+            print("EMPTY")
+        else:
+            print(-max_heap[0][0], min_heap[0][0])
+
+if __name__ == "__main__":
+    solve()