이것이 코딩 테스트다 PART3 with python : 최단거리

이것이 코딩 테스트다 PART3 with python : 최단거리

플로이드 (난이도 1.5)

INF = int(1e9)

# 노드의 개수, 간선의 개수
n = int(input())
m = int(input())

# 2차원 리스트(그래프 표현)를 만들고, 모든 값을 무한으로 초기화
graph = [[INF] * (n + 1) for _ in range(n + 1)]

# 자기 자신에서 자기 자신으로 가는 비용 0으로 초기화
for a in range(1,n+1):
    for b in range(1, n+1):
        if a == b:
            graph[a][b] = 0

# 각 간선에 대한 정보를 입력받아, 그 값으로 초기화
for _ in range(m):
    # A에서 B로 가는 비용C
    a, b, c = map(int, input().split())
    if c < graph[a][b]:
        graph[a][b] = c

for k in range(1,n+1):
    for a in range(1, n+1):
        for b in range(1, n+1):
            graph[a][b] = min(graph[a][k] + graph[k][b], graph[a][b])

for a in range(1, n + 1):
    for b in range(1, n + 1):
        if graph[a][b] == INF:
            print(0, end=' ')
        else:
            print(graph[a][b], end=' ')
    print()

정확한 순위 (난이도 2)

INF = int(1e9)

# 노드의 개수, 간선의 개수
n = int(input())
m = int(input())

# 2차원 리스트(그래프 표현)를 만들고, 모든 값을 무한으로 초기화
graph = [[INF] * (n + 1) for _ in range(n + 1)]

# 자기 자신에서 자기 자신으로 가는 비용 0으로 초기화
for a in range(1,n+1):
    for b in range(1, n+1):
        if a == b:
            graph[a][b] = 0

# 각 간선에 대한 정보를 입력받아, 그 값으로 초기화
for _ in range(m):
    # A에서 B로 가는 비용C
    a, b = map(int, input().split())
    graph[a][b] = 1

for k in range(1,n+1):
    for a in range(1, n+1):
        for b in range(1, n+1):
            graph[a][b] = min(graph[a][k] + graph[k][b], graph[a][b])

result = 0
for a in range(1, n + 1):
    count = 0
    for b in range(1,n+1):
    	# 도달가능 (= 성적비교 가능)
        if graph[a][b] != INF or graph[b][a] != INF:
            count +=1
    # 정확히 그 노드의 순위를 알고 있는 경우
    if count == n:
        result += 1
print(result)

화성 탐사(난이도 2)

import heapq
import sys
input = sys.stdin.readline
INF = int(1e9)

# 시계방향
dx = [0,1,0,-1]
dy = [-1,0,1,0]

for tc in range(int(input())):
    n = int(input())
	# 맵 정보
    graph = []
    for i in range(n):
        graph.append(list(map(int, input.split())))
        
	# 최단 거리 리스트
    distance = [[INF] * n for _ in range(n)]
	
    # 시작 위치
    x,y = 0, 0
    q = [(graph[x][y], x, y)]
    distance[x][y] = graph[x][y]

    while q:
        dist, x, y = heapq.heappop(q)
        if distance[x][y] < dist:
            continue
            
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if nx < 0 or nx >= n or ny < 0 or ny >= n:
                continue
            cost = dist + graph[nx][ny]
            # 경유해서 가는 경우가 더 비용이 적다면
            if cost < distance[nx][ny]:
                distance[nx][ny] = cost
                heapq.heappush(q,(cost,nx,ny))

    print(distance[n-1][n-1])

숨박꼭질(난이도 2)

import heapq
import sys

input = sys.stdin.readline
INF = int(1e9)

n, m = map(int, input().split())
start = 1

graph =[[] for i in range(n+1)]
distance = [INF] * (n+1)

for _ in range(m):
    a, b = map(int, input().split())
    # 양방향
    graph[a].append((b,1))
    graph[b].append((a,1))


def dijkstra(start):
    q = []
    # (거리, 노드번호)
    heapq.heappush(q,(0,start))
    distance[start] = 0
    while q:
        dist, now = heapq.heappop(q)
        if distance[now] < dist:
            continue
        for i in graph[now]:
        	# i[0]: 도착지, i[1] : 비용
            cost = dist + i[1]
            if cost < distance[i[0]]:
                distance[i[0]] = cost
                heapq.heappush(q,(cost, i[0]))


dijkstra(start)

max_node = 0
max_distance = 0
result = []

for i in range(1,n+1):
    if max_distance < distance[i]:
        max_node = i
        max_distance = distance[i]
        result = [max_node]
    elif max_distance == distance[i]:
        result.append(i)

print(max_node, max_distance, len(result))