Merge pull request #46 from bsa0322/jy/shortestPath/py

[최단 경로] 05월 03일 (선택, 필수 py)

Author: bsa0322

05월 03일 - 최단 경로/과제/10282.py

@@ -0,0 +1,49 @@
+import sys
+import heapq as hq
+input = sys.stdin.readline
+
+"""
+[해킹]
+- 기본적인 다익스트라 문제
+- 우선순위 큐에 삽입을 할 때는 이후 더 빠른 시간이 큐에 들어올 가능성이 있으므로 삽입할 때는 표기하지 않고, 큐에서 제거하는 시점에서 방문 표기 (큐에서 제거하는 시점에는 그때의 시간이 이후로 등장할 수 있는 가장 빠른시간이다.)
+
+ !주의! 그래프 생성 시, a가 b를 의존한다는 건 b 감염 후 a가 감염된다는 뜻이므로 b -> a 방향임
+"""
+
+def dijkstra(n, c, graph):
+    visited = [False] * (n+1)
+
+    pq = [(0, c)]
+    
+    t = 0
+    cnt = 0
+
+    while pq:
+        curr_t, curr = hq.heappop(pq)
+        if visited[curr]:
+            continue
+        visited[curr] = True
+        t = curr_t
+        cnt += 1
+        for next, weight in graph[curr]:
+            if not visited[next]:
+                hq.heappush(pq, (t + weight, next))
+    
+    return cnt, t
+
+
+# 입력
+t = int(input())
+
+for _ in range(t):
+    # 입력
+    n, d, c = map(int, input().split())
+    graph = [[] for _ in range(n+1)]
+
+    # 인접 리스트로 저장
+    for _ in range(d):
+        a, b, s = map(int, input().split())
+        graph[b].append((a, s))
+    
+    # 연산 + 출력
+    print(*dijkstra(n, c, graph))

05월 03일 - 최단 경로/과제/11559.py

@@ -0,0 +1,94 @@
+import sys
+from collections import deque
+input = sys.stdin.readline
+
+"""
+[Puyo Puyo] - bfs, 시뮬레이션 문제
+
+1. bfs 탐색을 통해 4개 이상의 뿌요가 모였는지 확인
+2. 4개 이상의 뿌요가 모였다면, 해당되는 영역을 '.'으로 바꾸어 비워줌
+3. 전체 필드에 대해 1~2를 다 수행한 후, 뿌요를 떨어뜨림
+    - 바닥부터 시작해서 남아있는 뿌요들을 모으고, 남은 부분은 '.'으로 채우는 방식
+4. 터뜨릴 수 없을 때까지 반복
+
+여기서, 3번 과정을 편하게 하기 위해 12*6으로 들어오는 입력을 6*12로 바꾸어준다.
+같은 열에 있는 데이터를 다루는 것보다 같은 행에 있는 데이터를 다루는 것이 편하기 때문이다.
+"""
+
+# 행과 열을 바꾸어 사용하므로 ROW를 6, COL은 12로 설정
+ROW = 6
+COL = 12
+
+def bfs(i, j):
+    dr = [-1, +1, 0, 0]
+    dc = [0, 0, -1, +1]
+    que = deque()
+    
+    que.append((i, j))
+    visited = [[False]*COL for _ in range(ROW)]
+    visited[i][j] = True
+    color = board[i][j]
+    count = 1   # 모여있는 뿌요의 개수
+    cords = []  # 포함된 좌표 저장할 리스트
+
+    while que:
+        cords.append(que[0])
+        r, c = que.popleft()
+        for x in range(4):
+            nr, nc = r+dr[x], c+dc[x]
+            if not (0 <= nr < ROW and 0 <= nc < COL):
+                continue
+            if not visited[nr][nc] and board[nr][nc] == color:
+                visited[nr][nc] = True
+                que.append((nr, nc))
+                count += 1
+    
+    if count < 4:
+        return False
+
+    for r, c in cords:
+        board[r][c] = '.'
+
+    return True
+
+# 뿌요를 터뜨린 이후의 새 필드를 작성하는 함수
+def make_new_board(board):
+    new_board = []
+    for i in range(ROW):
+        temp = []
+        for j in range(COL):
+            # 남아있는 뿌요를 임시 리스트에 모으기
+            if board[i][j] != '.':
+                temp.append(board[i][j])
+        # 비어 있는 부분을 '.'로 채우기
+        while len(temp) < COL:
+            temp.append('.')
+        new_board.append(temp[:])
+    return new_board
+
+# 입력
+board = [[None]*COL for _ in range(ROW)]
+
+# 행과 열을 바꾸어 저장
+for i in range(COL):
+    line = input().rstrip()
+    for j in range(ROW):
+        board[j][12-i-1] = line[j]
+        
+ans = 0
+
+while True:
+    flag = False
+    for i in range(ROW):
+        for j in range(COL):
+            if board[i][j] == '.':
+                continue
+            if bfs(i, j):
+                flag = True
+    
+    if not flag:
+        break
+    ans += 1
+    board = make_new_board(board)
+
+print(ans)

05월 03일 - 최단 경로/과제/1504.py

@@ -0,0 +1,59 @@
+import sys
+import heapq as hq
+input = sys.stdin.readline
+
+"""
+ [특정한 최단 경로]
+
+ 가능한 경로
+ 1. 1 -> v1 -> v2 -> n
+ 2. 1 -> v2 -> v1 -> n
+ -> 1, v1, v2를 시작점으로 하는 다익스트라 함수 실행하기
+
+ !주의!
+ 한 번 이동했던 정점, 간선을 다시 방문할 수 있음. 즉 1->N의 최댓값이 INF(1e5*8)이 아니라 3*INF!
+"""
+
+INF = 8*(10**5) * 3   # 최대 N-1개의 간선을 지나게 됨 * 중복 순회 가능(3)
+
+def dijkstra(n, graph, start):
+    dist = [INF]*(n+1)
+    pq = [(0, start)]
+
+    dist[start] = 0 
+
+    while pq:
+        weight, curr = hq.heappop(pq)
+        if weight > dist[curr]:
+            continue
+        for next, next_weight in graph[curr]:
+            new_weight = next_weight + weight
+            if new_weight < dist[next]:
+                dist[next] = new_weight
+                hq.heappush(pq, (new_weight, next))
+
+    return dist
+
+
+n, e = map(int, input().split())
+graph = [[] for _ in range(n+1)]
+
+for _ in range(e):
+    a, b, c = map(int, input().split())
+    graph[a].append((b, c))
+    graph[b].append((a, c))
+
+v1, v2 = map(int, input().split())
+
+dist = []
+for s in (1, v1, v2):
+    dist.append(dijkstra(n, graph, s))
+
+# 1->v1->v2->n의 경로와 1->v2->v1->n의 경로 중 최솟값
+# 무방향 그래프기 때문에 v1->v2와 v2->v1은 사실 같은 값!
+ans = min(dist[0][v1] + dist[1][v2] + dist[2][n], dist[0][v2] + dist[2][v1] + dist[1][n])
+
+if ans >= INF:
+    print(-1)
+else:
+    print(ans)

05월 03일 - 최단 경로/과제/1719.py

@@ -0,0 +1,45 @@
+import sys
+input = sys.stdin.readline
+
+"""
+ [택시]
+
+ graph : 플로이드-워셜 결과 행렬 그래프
+ table : 경로표. table[i][j] = i->j로 가기 위해 제일 먼저 거쳐야 하는 정점
+
+ 1. i->j의 중간 경로를 i로 초기화
+ 2. i->k->j가 i->j보다 짧다면 i->j의 중간 경로를 i->k의 중간 경로(table[i][k])로 갱신
+    k로 갱신하는게 아니라 table[i][k]로 갱신하는 이유는?
+    만약 i->k의 경로가 i->t->k라면 최종 경로는 i->t->k->j
+    바로 k로 갱신하면 t를 놓칠 수 있기 때문에 table[i][k]로 갱신
+    line 24을 table[i][j] = k로 바꾸면 결과가 어떻게 되는지 확인해보세요
+"""
+
+def floyd_warshall(n, graph, table):
+    for k in range(1, n+1):
+        for i in range(1, n+1):
+            for j in range(1, n+1):
+                if graph[i][k] + graph[k][j] < graph[i][j]:
+                    graph[i][j] = graph[i][k] + graph[k][j]
+                    table[i][j] = table[i][k]
+    return
+
+INF = 10**5 * 2
+n, m = map(int, input().split())
+graph = [[INF]*(n+1) for _ in range(n+1)]
+table = [[0]*(n+1) for _ in range(n+1)]
+
+for _ in range(m):
+    a, b, s = map(int, input().split())
+    graph[a][b] = graph[b][a] = s
+
+    table[a][b] = b
+    table[b][a] = a
+
+floyd_warshall(n, graph, table)
+
+for i in range(1, n+1):
+    table[i][i] = '-'
+
+for line in table[1:]:
+    print(*line[1:])

05월 03일 - 최단 경로/과제/18111.py

@@ -0,0 +1,58 @@
+import sys
+input = sys.stdin.readline
+
+INF = 10**9
+
+"""
+[마인크래프트]
+ 1. 가장 낮은 땅의 높이를 h라고 할 때, h-1의 높이를 만드는건 h보다 2*(N*M)의 시간이 더 소요됨
+ 2. 가장 높은 땅의 높이를 h라고 할 때, h+1의 높이를 만드는건 h보다 (N*M)의 시간이 더 소요됨
+ -> 따라서 땅의 높이가 될 수 있는 후보는 (가장 낮은 땅) ~ (가장 높은 땅)
+ -> 위치에 관계없이, 높이에 따라 필요한 블록 수와 시간이 결정되기 때문에 해당 높이의 블록이 몇 개 있는지 미리 저장 -> 가능한 높이 당 최대 256번의 연산만으로 계산 가능
+
+ !주의! 당장 쌓을 블록이 없더라도 언젠가 다른 곳의 블록을 제거해서 쌓을 수 있음.
+"""
+
+def mine_land(min_height, max_height, b, height, cnt):
+    t = 0
+    for i in range(min_height, height):
+        temp = cnt[i] * (height - i)
+        b -= temp
+        t += temp
+
+    for i in range(height, max_height + 1):
+        temp = cnt[i] * (i - height)
+        b += temp
+        t += temp * 2
+
+    if b < 0:
+        return INF + 1
+
+    return t
+
+
+# 입력
+n, m, b = map(int, input().split())
+
+cnt = [0]*257   # cnt[i] = 높이 i를 가지고 있는 땅의 수
+min_height = 256
+max_height = 0
+
+for _ in range(n):
+    for i in map(int, input().split()):
+        cnt[i] += 1
+        min_height = min(min_height, i)
+        max_height = max(max_height, i)
+
+min_t = INF
+height = 0
+
+# 연산
+for h in range(min_height, max_height+1):
+    t = mine_land(min_height, max_height, b, h, cnt)
+    if t <= min_t:
+        min_t = t
+        height = h
+
+# 출력
+print(min_t, height)

05월 03일 - 최단 경로/과제/1865.py

@@ -0,0 +1,52 @@
+import sys
+input = sys.stdin.readline
+
+"""
+ [웜홀]
+
+ 벨만-포드 문제
+
+ 시간이 되돌아가서 출발 지점에 도착하는 경우 = 음의 사이클이 생긴 경우
+
+ 특별히 시작점이 주어지지 않았으므로, 벨만-포드를 특정 정점에서 시작하는 경우만 돌릴 시 해당 정점에서 닿을 수 없는 음의 사이클의 존재를 판단할 수 없음
+ 그러나, 모든 정점에서 벨만-포드 연산을 하게 되면 O(n^2*E)의 시간 복잡도가 걸려서 효율적이지 않음
+ => 모든 정점에 도달할 수 있는 임의의 가짜 정점 0을 만들어서 시작점을 0으로 하는 한 번의 벨만-포드 연산으로 그래프 전체에 대한 음의 사이클 존재 여부 판단!
+ => 이때, 가짜 정점 0에서 모든 정점으로의 거리가 0인 간선이 있다고 가정하여 dist배열을 0으로 초기화
+"""
+
+def bellman_ford(n, edges):
+    dist = [0] * (n+1)  # (추가 제출 시) 0으로 초기화한 이유 꼭 적어주세요!
+
+    for i in range(n+1):
+        flag = False
+
+        for s, e, t in edges:
+            if dist[s] + t < dist[e]:
+                dist[e] = dist[s] + t
+                flag = True
+
+        if not flag:
+            return "NO"
+
+        if i == n:
+            return "YES"
+
+tc = int(input())
+for _ in range(tc):
+
+    # 입력
+    n, m, w = map(int, input().split())
+
+    edges = []
+
+    for _ in range(m):
+        s, e, t = map(int, input().split())
+        edges.append((s, e, t))
+        edges.append((e, s, t))
+
+    for _ in range(w):
+        s, e, t = map(int, input().split())
+        edges.append((s, e, -t))
+    
+    
+    print(bellman_ford(n, edges))