Dain Lee / 19주차

crolvlee/chap07/2512_예산.py

@@ -2,7 +2,7 @@
 
 N = int(input())
 lst = list(map(int, sys.stdin.readline().split()))
-M = int(input())    # 예산 상한선
+M = int(input())    # 빌려줄 수 있는 총액
 
 start = 0
 end = max(lst)
@@ -14,16 +14,16 @@
     # 상한 금액이 mid일 때, 받는 요청 금액의 합 total 구하기
     total = 0
     for l in lst:
-        if l >= mid:
+        if l >= mid:        # 상한금액 mid를 넘으면
             total += mid
-        else:
+        else:               # 상한 금액 mid를 넘지 않으면
             total += l
 
     # total이 주어진 금액을 초과하는지 여부에 따라 포인트 재설정
     if total <= M:
         answer = mid        # 현재 mid값이 가능하긴 함
-        start = mid + 1     # 현재 mid값보다는 작은 범위를 탐색
+        start = mid + 1     # 현재 mid값보다는 큰 범위를 탐색
     else:
-        end = mid - 1       # 현재 mid값보다는 큰 범위를 탐색
+        end = mid - 1       # 현재 mid값보다는 작은 범위를 탐색
 
 print(answer)

crolvlee/chap09/11403_경로찾기.py

@@ -0,0 +1,18 @@
+# 입력
+N = int(input())
+graph = []
+for _ in range(N):
+  graph.append(list(map(int, input().split())))
+
+# 플로이드 알고리즘
+for k in range(N):
+  for i in range(N):
+    for j in range(N):
+      if graph[i][j] == 1 or (graph[i][k] == 1 and graph[k][j] == 1):
+        graph[i][j] = 1
+
+# 출력
+for row in graph:
+  for col in row:
+    print(col, end=" ")
+  print()

crolvlee/chap09/1916_최소비용구하기.py

@@ -0,0 +1,57 @@
+import sys
+import heapq
+
+input = sys.stdin.readline
+INF = int(1e9)
+
+N = int(input())  # 도시의 개수
+M = int(input())  # 버스의 개수
+
+# 각 도시에 연결되어 있는 도시에 대한 정보를 담는 이차원 리스트
+graph = [[] for i in range(N + 1)]
+# graph = [
+#         []
+#         [(2, 2), (3, 3), (4, 1), (5, 10)]
+#         [(4, 2)]
+#         ]
+
+# 방문한적이 있는 도시를 체크하기 위한 리스트
+visited = [False] * (N + 1)
+
+# 최단 거리 테이블 -> 무한대로 초기화
+distance = [INF] * (N + 1)
+
+# graph에 정보 채우기
+for _ in range(M):
+    u, v, w = map(int, input().split())
+    graph[u].append((v, w))
+
+# 출발점의 도시번호와 도착점의 도시번호
+start, end = map(int, input().split())
+
+# 다익스트라 함수
+def dijkstra(start):
+    q = []
+    heapq.heappush(q, (0, start))   # 큐에 (비용, 도시번호)가 들어감
+    distance[start] = 0             # 최단거리 테이블 시작노드는 0으로
+
+    while q:
+        # 가장 최단거리가 짧은 도시에 대한 정보 꺼내기
+        curCost, curNode = heapq.heappop(q)
+
+        # 테이블에 있는 값보다 큐에 있는 비용이 크다면, 이미 방문한 노드임
+        if distance[curNode] < curCost:
+            continue
+
+        # 현재 노드와 연결된 다른 인접한 노드들을 확인
+        for i in graph[curNode]:
+            cost = curCost + i[1]
+            # 현재 노드를 거쳐서 다른 노드로 이동하는 거리가 더 짧은 경우
+            if cost < distance[i[0]]:
+                distance[i[0]] = cost
+                heapq.heappush(q, (cost, i[0]))
+
+# 다익스트라 알고리즘 수행
+dijkstra(start)
+
+print(distance[end])

crolvlee/chap09/2606_바이러스.py

@@ -0,0 +1,30 @@
+# 1번 컴퓨터를 출발 노드로 설정
+
+# 특정 컴퓨터와 연결되어 있는 컴퓨터에 방문하지 않았다면 그 컴퓨터의 번호를 매개변수로 전달하면서 재귀호출
+# 함수가 호출되는 수 == 감염된 컴퓨터의 수
+
+
+
+N = int(input())  # 컴퓨터의 개수
+M = int(input())  # 연결된 컴퓨터 쌍의 개수
+
+def dfs(graph, v, visited):
+  global cnt
+  visited[v] = True   # 방문했으니 True로 바꿔줌
+  for i in graph[v]:
+    if visited[i] == False:
+      cnt += 1
+      dfs(graph, i, visited)
+
+graph = [[] for _ in range(N+1)]
+visited = [False] * (N+1)
+cnt = 0   # 함수가 호출되는 수 (감염된 컴퓨터의 수)
+
+# 그래프에 연결된 컴퓨터들 채워넣기
+for i in range(M):
+  a, b = map(int, input().split())
+  graph[a].append(b)
+  graph[b].append(a)
+
+dfs(graph, 1, visited)
+print(cnt)

crolvlee/chap10/1325_효율적인해킹.py

@@ -0,0 +1,44 @@
+import sys
+input = sys.stdin.readline
+
+def dfs(node, graph, visited):
+    stack = [node]
+    count = 0
+
+    while stack:
+        current = stack.pop()
+        if not visited[current]:
+            visited[current] = True
+            count += 1
+            for neighbor in graph[current]:
+                if not visited[neighbor]:
+                    stack.append(neighbor)
+
+    return count
+
+
+# 입력 받음
+n, m = map(int, input().split())
+
+# 그래프 초기화
+graph = [[] for _ in range(n+1)]
+for _ in range(m):
+    a, b = map(int, input().split())
+    graph[b].append(A)
+
+# 각 컴퓨터에서 해킹할 수 있는 컴퓨터 수를 계산
+max_hack_count = 0
+result = []
+
+for i in range(1, n + 1):
+    visited = [False] * (n + 1)
+    hack_count = dfs(i, graph, visited)
+    if hack_count > max_hack_count:
+        max_hack_count = hack_count
+        result = [i]
+    elif hack_count == max_hack_count:
+        result.append(i)
+
+# 결과 출력
+result.sort()
+print(' '.join(map(str, result)))

crolvlee/chap10/2660_회장뽑기.py

@@ -0,0 +1,45 @@
+import sys
+input = sys.stdin.readline
+INF = float('inf')
+
+# 입력받음
+n = int(input())
+
+# 그래프 초기화
+dist = [[INF] * (n+1) for _ in range(n+1)]
+for i in range(1, n+1):
+    dist[i][i] = 0
+
+# 연결된 노드들을 그래프에 담음
+while True:
+    a, b = map(int, input().split())
+    if a == -1 and b == -1:
+        break
+    dist[a][b] = 1
+    dist[b][a] = 1
+
+# 플로이드 알고리즘
+for k in range(1, n+1):
+    for i in range(1, n+1):
+        for j in range(1, n+1):
+            if dist[i][j] > dist[i][k] + dist[k][j]:
+                dist[i][j] = dist[i][k] + dist[k][j]
+
+# 각 회원의 점수 계산
+scores = []
+for i in range(1, n+1):
+    max_distance = max(dist[i][1:])
+    scores.append((max_distance, i))
+
+min_score = min(scores)[0]
+candidates = []
+for score, member in scores:
+    if score == min_score:
+        candidates.append(member)
+
+# 후보의 회원번호를 오름차순으로 정렬
+candidates.sort()
+
+print(min_score, len(candidates))
+for candidate in candidates:
+    print(candidate, end=' ')

crolvlee/chap10/5567_결혼식.py

@@ -0,0 +1,36 @@
+# 1번 노드부터 탐색
+
+# dfs함수
+def dfs(graph, current, visited, depth):
+    if depth > 2:   # 친구의 친구까지만 초대할 거니까
+        return
+
+    visited[current] = True     # 현재 노드를 방문 처리
+
+    for neighbor in graph[current]:
+        if not visited[neighbor]:
+            dfs(graph, neighbor, visited, depth+1)
+
+
+# 입력 받음
+n = int(input())    # 동기의 수
+m = int(input())    # 리스트의 길이
+
+# 각 노드가 연결된 정보
+graph = [[] for _ in range(n+1)]
+
+# 각 노드가 방문된 정보를 리스트로 표현
+visited = [False] * (n+1)
+
+# graph에 연결된 정보 담음
+for _ in range(m):
+    a, b = map(int, input().split())
+    graph[a].append(b)
+    graph[b].append(a)
+
+
+# dfs 수행
+dfs(graph, 1, visited, 0)
+
+invite_count = visited.count(True) - 1  # 1번 노드(본인) 제외하고 카운트
+print(invite_count)

crolvlee/other/10844_쉬운계단수.py

@@ -0,0 +1,30 @@
+# 길이가 i이고, j로 끝나는 계단수의 개수 (j = 1, 2, 3, ... 7, 8)
+# = (길이가 i-1이고, j-1로 끝나는 계단수의 개수) + (길이가 i-1이고 j+1로 끝나는 계단수의 개수
+
+# 길이가 i이고, 0으로 끝나는 계단수의 개수
+# = 길이가 (i-1)이고, 1로 끝나는 계단수의 개수
+
+# 길이가 i이고, 9로 끝나는 계단수의 개수
+# = 길이가 (i-1)이고 8로 끝나는 계단수의 개수
+
+N = int(input())
+
+# dp[i][j] : 길이가 i이고 j로 끝나는 계단수의 개수
+dp = [[0] * 10 for _ in range(N+1)]
+
+# 길이가 1인 계단수의 개수 초기화
+for j in range(1, 10):
+    dp[1][j] = 1
+
+# dp 채우기
+for i in range(2, N+1):
+    for j in range(10):
+        if j == 0:
+            dp[i][j] = dp[i-1][1]
+        elif j == 9:
+            dp[i][j] = dp[i-1][8]
+        else:
+            dp[i][j] = dp[i-1][j-1] + dp[i-1][j+1]
+
+
+print(sum(dp[N]) % 1000000000) 

crolvlee/other/1439_뒤집기.py

@@ -0,0 +1,8 @@
+S = input()
+
+cnt = 0 
+for i in range(len(S) - 1):
+    if S[i] != S[i+1]:
+        cnt += 1
+
+print((cnt+1) // 2)

crolvlee/other/15903_카드합체놀이.py

@@ -0,0 +1,13 @@
+import sys
+input = sys.stdin.readline
+
+a,b = map(int, input().split())
+card  = list(map(int,input().split()))
+
+for i in range(b):
+    card = sorted(card)
+    cover = card[0] + card[1]
+    card[0] = cover
+    card[1] = cover
+
+print(sum(card))

crolvlee/other/2468_안전영역.py

@@ -0,0 +1,43 @@
+from collections import deque
+
+# BFS 함수 정의
+def bfs(x, y, height, visited, graph):
+    # 이동 방향 (상, 하, 좌, 우)
+    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+    queue = deque([(x, y)])
+    visited[x][y] = True
+
+    while queue:
+        cx, cy = queue.popleft()
+
+        for dx, dy in directions:
+            nx, ny = cx + dx, cy + dy
+
+            if 0 <= nx < N and 0 <= ny < N and not visited[nx][ny] and graph[nx][ny] > height:
+                visited[nx][ny] = True
+                queue.append((nx, ny))
+
+
+N = int(input())
+graph = []
+for _ in range(N):
+    graph.append(list(map(int, input().split())))
+
+# 최대 안전 영역 개수
+result = 0
+
+# 강수량을 0부터 100까지 변화시키며 안전영역을 계산
+for height in range(101):
+    visited = [[False] * N for _ in range(N)]
+    safe_areas = 0
+
+    for i in range(N):
+        for j in range(N):
+            if graph[i][j] > height and visited[i][j] == False:
+                bfs(i, j, height, visited, graph)
+                safe_areas += 1
+
+    result = max(result, safe_areas)
+
+print(result)