ADD : 29.py

SYCHOI/21to30/29.py

@@ -28,9 +28,6 @@ def solution(enroll, referral, seller, amount) :
 
 
 
-
-
-
 
 #TEST 코드입니다. 주석을 풀어서 확인해보세요
 print(solution(["john", "mary", "edward", "sam", "emily", "jaimie", "tod", "young"], ["-", "-", "mary", "edward", "mary", "mary", "jaimie", "edward"], ["young", "john", "tod", "emily", "mary"], [12, 4, 2, 5, 10]))

SYCHOI/31to40/31.py

@@ -0,0 +1,38 @@
+from collections import deque
+
+def solution(info, edges) :
+    def build_tree(info, edges) :       # 트리 구축 함수
+        tree = [[] for _ in range(len(info))]
+        for edge in edges :
+            tree[edge[0]].append(edge[1])
+        return tree
+
+    tree = build_tree(info, edges)      # 트리 생성
+    max_sheep = 0                       # 최대 양의 수를 저장할 변수 초기화
+
+    # BFS를 위한 큐 생성 및 초기 상태 설정
+    q = deque([(0, 1, 0, set())])       # (현재 위치, 양의 수, 늑대의 수, 방문한 노드 집합)
+
+    # BFS 시작
+    while q :
+        current, sheep_count, wolf_count, visited = q.popleft()     # 큐에서 상태 가져오기
+        max_sheep = max(max_sheep, sheep_count)                     # 최대 양의 수 업데이트
+        visited.update(tree[current])                               # 방문한 노드 집합에 현재 노드의 이웃 노드 추가
+
+        for next_node in visited :      # 인접한 노드들에 대해 탐색
+            if info[next_node] :        # 늑대의 경우
+                if sheep_count != wolf_count + 1 :
+                    q.append(
+                        (next_node, sheep_count, wolf_count + 1, visited - {next_node})
+                    )
+                else :                  # 양의 경우
+                    q.append(
+                        (next_node, sheep_count + 1, wolf_count, visited - {next_node})
+                    )
+
+    return max_sheep
+
+
+#TEST 코드입니다. 주석을 풀어서 확인해보세요
+print(solution([0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1], [[0, 1], [1, 2], [1, 4], [0, 8], [8, 7], [9, 10], [9, 11], [4, 3], [6, 5], [4, 6], [8, 9]]))
+print(solution([0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0], [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6], [3, 7], [4, 8], [6, 9], [9, 10]]))

SYCHOI/31to40/37.py

@@ -0,0 +1,45 @@
+def find(parent, i) :
+    if parent[i] == i :
+        return i
+
+    parent[i] = find(parent, parent[i])
+    return parent[i]
+
+def union(parent, rank, x, y) :
+    xroot = find(parent, x)
+    yroot = find(parent, y)
+
+    if rank[xroot] < rank[yroot] :
+        parent[xroot] = yroot
+    elif rank[xroot] > rank[yroot] :
+        parent[yroot] = xroot
+    else :
+        parent[yroot] = xroot
+        rank[xroot] += 1
+
+def solution(n, costs) :
+    costs.sort(key=lambda x : x[2])
+
+    parent = [i for i in range(n)]
+    rank = [0] * n
+
+    min_cost = 0
+    edges = 0
+
+    for edge in costs :
+        if edges == n - 1 :
+            break
+
+        x = find(parent, edge[0])
+        y = find(parent, edge[1])
+
+        if x != y :
+            union(parent, rank, x, y)
+            min_cost += edge[2]
+            edges += 1
+
+    return min_cost
+
+
+#TEST 코드입니다. 주석을 풀어서 확인해보세요
+print(solution(4, [[0, 1, 1], [0, 2, 2], [1, 2, 5], [1, 3, 1], [2, 3, 8]]))

SYCHOI/31to40/38.py

@@ -0,0 +1,28 @@
+from collections import defaultdict
+
+def solution(graph, start) :
+    adj_list = defaultdict(list)        # 그래프를 인접 리스트로 변환
+    for u, v in graph :
+        adj_list[u].append(v)
+
+    # DFS 탐색 함수
+    def dfs (node, visited, result) :
+        visited.add(node)       # 현재 노드를 방문한 노드들의 집합에 추가
+        result.append(node)     # 현재 노드를 결과 리스트에 추가
+
+        for neighbor in adj_list.get(node, []) :        # 현재 노드와 인접한 노드 순회 
+            if neighbor not in visited :                # 아직 방문하지 않은 노드라면
+                dfs(neighbor, visited, result)          # dfs 탐색
+
+    # DFS를 순회한 결과 반환
+    visited = set()
+    result = []
+    dfs(start, visited, result)     # 시작 노드에서 깊이 우선 탐색 시작
+
+    return result
+
+
+
+#TEST 코드입니다. 주석을 풀어서 확인해보세요
+print(solution([['A', 'B'], ['B', 'C'], ['C', 'D'], ['D', 'E']], 'A'))
+print(solution([['A', 'B'], ['A', 'C'], ['B', 'D'], ['B', 'E'], ['C', 'F'], ['E', 'F']], 'A'))

SYCHOI/31to40/39.py

@@ -0,0 +1,31 @@
+from collections import defaultdict, deque
+
+def solution(graph, start) :
+    adj_list =defaultdict(list)
+    for u, v in graph :
+        adj_list[u].append(v)
+
+    def bfs(start) :
+        visited = set()
+
+        queue = deque([start])
+        visited.add(start)
+        result.append(start)
+
+        while queue :
+            node = queue.popleft()
+            for neighbor in adj_list.get(node, []) :
+                if neighbor not in visited :
+                    queue.append(neighbor)
+                    visited.add(neighbor)
+                    result.append(neighbor)
+
+    result = []
+    bfs(start)
+    return result
+
+
+#TEST 코드입니다. 주석을 풀어서 확인해보세요
+print(solution([(1,2), (1,3), (2,4), (2,5), (3,6), (3,7), (4,8), (5,8), (6,9), (7,9)], 1))
+print(solution([(0,1), (1,2), (2,3), (3,4), (4,5), (5,0)], 1))
+

SYCHOI/31to40/40.py

@@ -0,0 +1,32 @@
+import heapq
+
+def solution(graph, start) :
+    distances = {node: float("inf") for node in graph}      # 모든 노드의 거리 값을 무한대로 초기화
+    distances[start] = 0                                    # 시작 노드의 거리 값은 0으로 초기화
+    queue = []
+    heapq.heappush(queue, [distances[start], start])        # 시작 노드를 큐에 삽입
+    paths = {start: [start]}                                # 시작 노드의 경로를 초기화
+
+    while queue :                                                               
+        current_distance, current_node = heapq.heappop(queue)                       # 현재 가장 거리 값이 작은 노드를 가져옴
+
+        if distances[current_node] < current_distance :                             # 만약 현재 노드의 거리 값이 큐에서 가져온 거리 값보다 크면
+            continue                                                                # 해당 노드는 이미 처리한 것으로 무시
+
+        for adjacent_node, weight in graph[current_node].items() :
+            distance = current_distance + weight                                    # 현재 노드와 인접한 노드들의 거리 값을 계산하여 업데이트
+
+            if distance < distances[adjacent_node] :                                # 현재 계산한 거리 값이 기존 거리 값보다 작으면
+                distances[adjacent_node] = distance                                 # 최소 비용 업데이트
+                paths[adjacent_node] = paths[current_node] + [adjacent_node]        # 최단 경로 업데이트
+
+                heapq.heappush(queue, [distance, adjacent_node])                    # 최소 경로가 갱신된 노드를 비용과 함께 큐에 푸시
+
+    sorted_paths = {node: paths[node] for node in sorted(paths)}
+
+    return [distances, sorted_paths]
+
+
+#TEST 코드입니다. 주석을 풀어서 확인해보세요
+print(solution({'A': {'B':9, 'C':3}, 'B' : {'A', 5}, 'C' : {'B', 1}}, 'A'))
+print(solution({'A':{'B':1}, 'B':{'C':5}, 'C':{'D',1}, 'D':{}}, 'A'))