25-janghw0126

[janghw0126]

🔗 문제 링크

백준 | 녹색 옷 입은 애가 젤다지?

✔️ 소요된 시간

2시간(고민한 시간) + 6시간(다른 분들이 쓴 코드 뜯어보는데 걸린 시간)

✨ 수도 코드

태규님이 이전 PR 때 다익스트라 알고리즘을 추천해줘서 한번 시도해 보았습니다! 새로 접한 개념이라 그런지 쉽지 않더군여,,그치만 더 많이 고민하고 풀어보면서 다익스트라를 뿌셔보도록 하겠습니다👊👊

Note

다익스트라 알고리즘이란?

• 다이나믹 프로그래밍을 활용한 대표적인 최단 경로(최소 비용이 드는 경로) 탐색 알고리즘이다.
• 특정한 하나의 정점에서 다른 모든 정점으로 가는 최단 경로를 알려준다.
• 이 과정에서 도착 정점 뿐만 아니라 모든 다른 정점까지 최단 경로로 방문하여 각 정점까지의 최단 경로를 모두 찾게 된다. 즉, 매번 최단 경로의 정점을 선택해 탐색을 반복하는 것이다.

예를 들어보자.

위의 그림에서 1부터 다른 모든 노드로 가는 최단 경로를 구해야 한다고 가정해보자.

처음에는 다음과 같이 1에 인접해 있는 노드인 2, 3, 4까지의 최단 거리 즉, 최소 비용이 3, 6, 7이라는 것을 알 수 있다.

이후에 다음 노드인 2를 처리하게 되면, 경로 1 → 3의 비용이 6인 반면에 경로 1 → 2 → 3의 총 비용이 4라는 것을 알 수 있다. 즉, 현재까지 알고있던 3으로 가는 최소 비용인 6을 새로운 비용인 4로 갱신한다는 것이다.

이를 통해 다익스트라 알고리즘은 현재까지 알고 있던 최단 경로를 계속해서 갱신한다는 것을 알 수 있다.

이를 바탕으로 이번 문제를 한번 풀어보았다. 아직 내 머리로는 스스로 풀기엔 역부족인 것 같아서 다른 분의 블로그를 참고하였다.

📖BFS + 다익스트라를 이용한 풀이 방법
이 문제는 BFS개념을 이용해서 풀어도 될 것 같아서 한번 시도해보았다. 하지만 아직 BFS개념을 완전정복하지 못해서 생각보다 시간이 많이 걸렸던 것 같다.

1. 지도 정보를 저장할 리스트를 선언한다. 여기서 안에 있는 숫자를 최소로 비교하면서 들어갈 것이기 때문에 무한으로 설정해준다.
2. 경로를 지나갈 bfs() 함수를 만든다. 경로를 하나하나 꺼내가면서 큐에 현재 위치를 넣고, 상하좌우로 이동 가능한 위치를 탐색하면서 비용을 갱신할 것이기 때문에 BFS방식을 가져온다.
3. queue 안에 갱신된 위치를 넣어주고 탐색할 위치를 순차적으로 저장하면서 방문 순서대로 처리한다.
4. queue 안이 빌 때까지 즉, 모든 가능한 위치를 탐색할 때까지 반복해준다.
5. queue의 종료 구문을 설정해준다.
6. 각 위치로 이동할 때마다 최소 비용을 갱신하며, 최종적으로 목적지까지의 최소 비용을 계산한다.

⬇️최종 코드

# 양방향 큐 모듈을 불러온다.
from collections import deque  
# 문제 번호를 세기 위한 count와, 상하좌우 이동을 위한 dx, dy 배열을 정의한다.
count, dx, dy = 0, [0, 0, 1, -1], [1, -1, 0, 0] 

# 너비 우선 탐색(BFS) 함수를 정의한다.
def bfs(): 
    queue = deque() 
    # 시작점을 queue에 추가한다.
    queue.append([0, 0])  
    # 시작점의 비용을 초기화한다.
    cost[0][0] = field[0][0]  
    # queue에 요소가 있는 동안 반복한다.
    while queue:  
        # queue에서 요소를 하나 꺼내 x, y에 할당한다.
        x, y = queue.popleft() 
        # 상하좌우 네 방향에 대해 반복한다.
        for i in range(4):  
            # 현재 위치에서 이동할 새로운 위치를 계산한다.
            nx, ny = x + dx[i], y + dy[i] 
             # 새로운 위치가 범위 내에 있는지 확인한다.
            if -1 < nx < n and -1 < ny < n: 
                # 새로운 위치로 이동하는 비용이 더 저렴한지 확인하고 더 저렴한 경우 비용을 갱신한 후 갱신된 위치를 queue에 추가한다.
                if cost[y][x] + field[ny][nx] < cost[ny][nx]: 
                    cost[ny][nx] = cost[y][x] + field[ny][nx] 
                    queue.append([nx, ny]) 
    # 목적지까지의 최소 비용을 반환한다.
    return cost[n-1][n-1]  


while True:
    n = int(input())  
    if n == 0: 
        break  
    # 문제 번호를 1 증가시킨다.
    count += 1
    # 지도 정보를 저장할 리스트를 초기화한다.
    field = []  
    # 지도 정보를 입력받아 field에 저장한다.
    for i in range(n): field.append(list(map(int, input().split()))) 
    # 각 위치까지의 최소 비용을 저장할 리스트를 무한대로 초기화한다.
    cost = [[1e9 for j in range(n)] for i in range(n)]  
    # 각 테스트 케이스의 결과를 출력한다.
    print(f"Problem {count}: {bfs()}")  

📖다익스트라만을 이용한 풀이 방법
다익스트라만을 이용해서 풀 때는 인접한 노드를 구할 때 해당 좌표의 상하 좌우를 가지고 오면 된다.

👀코드를 참고한 블로그

⬇️최종 코드

# 다익스트라 알고리즘을 위해 힙 모듈을 불러온다.
import heapq
# 입력을 받는다.
result = []
n = int(input())
while n!=0:
    graph  = [[1] for _ in range(n)]
    for idx in range(n):
        graph[idx] = list(map(int, input().split()))
    # 잃어버리는 돈 양을 저장하는 배열을 초기화한다.
    loss = [[float('inf')]*n for _ in range(n) ]
    # 상하좌우를 이동하는 변수를 각각 선언한다.
    dx = [0,0,-1,1]
    dy = [-1,1,0,0]
    # 우선순위 큐를 초기화한다.
    q = []
    # 우선순위 큐에 시작점인 (0,0)의 정보를 넣는다. 
    heapq.heappush(q,(graph[0][0] , [0,0]))
    # (0,0)에서 시작하기 때문에 loss[0][0]을 graph[0][0]으로 지정한다.
    loss[0][0] = graph[0][0]
    # 우선순위 큐가 빌 때까지 반복한다.
    while q:
        # 큐에서 제일 weight가 작은 값을 뽑아온다.
        weight,(x,y) = heapq.heappop(q)
        # 만약 이미 가장 작은 값으로 된 값이면 그냥 넘긴다.
        if loss[x][y] < weight:
            continue
        # 인접한 4개의 노드 중 갈 수 있는 노드 이면 해당되는 문이다.
        for idx in range(4):
            xx = x + dx[idx]
            yy = y + dy[idx]
            if (0<=xx<n) and (0<=yy<n):
                cost = weight + graph[xx][yy]
                # 해당 좌표로 가는 값이 최소 값이라면 해당되는 문이다.
                if loss[xx][yy] > cost:
                    # 해당 값을 loss에 저장하고 우선순위 큐에 해당 값을 추가한다. 
                    loss[xx][yy] = cost
                    heapq.heappush(q,(cost , [xx,yy]))
    result.append(loss[-1][-1])
    n = int(input())

for idx in range(len(result)):
    print(f"Problem {idx+1}: {result[idx]}")

📚 새롭게 알게된 내용

다익스트라,,이름만 들어도 쉽지 않은 것 같았지만 코드를 찬찬히 뜯어보니 할 만한 것 같기두,,? 음,,,좀 더 노력해 보아야겠습니다,, 갈 길이 머네요,,하핫🤣🤣

[tgyuuAn]

헉 뭔가 혜원님은 @gjsk132 나영님의 스멜이 조금 나요. (긍정의 의미입니다...!)

이거 해볼래요 ? 하면 해보겠씁니다! 하고... 하나를 착 가르쳐주면 두개를 척척하는... 👍👍

[janghw0126]

@tgyuuAn 태규님이 추천해주신 덕분에 다양한 자료구조를 더 많이 알아가고 있습니다!
앞으로 더 욜심히 해보겠습니닷,,,😎😎

[LJEDD2]

@janghw0126 큐티걸

[Hwangyerin]

다익스트라...! 친절한 수도코드 덕분에 이해하는데 많은 도움이 되었습니다!
혜원님 대단하시네요.. 저는 아직 무서워서 건들지 못하고 있습니다ㅜ
그래프 개념부터 차근차근히 밟고 다시 이 PR을 완벽히 이해하고 문제 풀 수 있을 때 다시 풀어봐야겠어요
수고하셨습니다!

[LJEDD2]

마지막 코드에서는 Heapq 모듈을 사용하여 문제를 해결한 것으로 보이는데 너비 탐색 알고리즘을 사용한 코드와 어떤 차이를 가지는지 궁금합니다 🧐🧐🧐

[avocado-13]

혜원님의 상세한 설명덕분에 잊고 있던 다익스트라 알고리즘을 상기시킬 수 있었습니다!
bfs를 사용한 코드와 다익스트라만을 사용한 코드 모두 보여주셔서 다양한 방법을 익힐 수 있었습니다😄👍 마지막 출력에서 f-string도 다시금 익히고 갑니다... 수고하셨습니다!!