13-wnsmir

[wnsmir]

🔗 문제 링크

이것이 코딩테스트다 실전문제중 chapter 최단경로의 1번문제 발췌입니다.
균호님 12번째 PR과 비슷한 문제를 복습겸 풀어보고자 가져와봤습니다.
비슷하지만 다른접근으로 풀어 좀 오래걸렸습니다,,

미래도시 - 난이도2/3 - 풀이시간 40min - 메모리제한 128MB
문제
방문판매원 A는 현재 1번회사에 위치해있으며 X번 회사에 방문해 물건을 판매하고자 한다. 미래도시에서 회사는 회사끼리 연결되어있는 통로로만 이동가능하고, 이 통로는 항상 어디든 1의시간으로 양방향으로 이동할 수 있다.
A는 1번에서 X번까지 가야하는데 도중 소개팅을 해야한다. 소개팅 상대는 K번 회사를 방문한 뒤 X회사로 가는것이 목표이다.

현위치에서 K를거쳐 X로 이동하는 A의 최단 이동시간을 구하여라.

입력은 첫줄에 N과M이 공백을 두고 주어지고, 다음 M개의 줄에 각 회사들의 통로 관계가 주어진다. 마지막줄은 X와 K가 공백을 두고 주어진다.
만약 도달할 수 없다면 -1을 출력한다.
(1<=N, M<=100), (1<=K<=100)
입력예시
5 7
1 2
1 3
1 4
2 4
3 4
3 5
4 5
4 5
출력예시
3

✔️ 소요된 시간

50min

✨ 수도 코드

이전 균호님 문제는 BFS로 최단거리를 활용하여 풀었습니다. 즉 인접리스트를 활용해 문제를 풀었는데요, 이 문제는 모든 통로의 가중치가 1이라 BFS로도 풀 수 있을것 같지만, 다르게 풀어보기 위해 거쳐가는 최단경로 알고리즘 플로이드위셜을 활용해 보았습니다.

플루이드 위셜은 생각보다 간단한 동적배열 알고리즘의 일종인데,
인접행렬을 활용하여 출발노드와 도착노드를 모두 N번씩 돌아가며 최소한의 거리를 구하는데, 이때 제일 바깥 반복문 K를 활용해 출발과 도착노드 사이에 다른노드 하나를 추가해 업데이트해 나가는 방식입니다.
즉 1과 3의 가중치가 3인데 1->2->3이 2라면 1과2, 2와3의 가중치의 합으로 1->3의 가중치를 덮어씌우는 느낌입니다.

따라서 시간복잡도는 반복문 3번 N^3일 것입니다.

[kangrae-jo]

저는 이전 리뷰에서도 썼던 알고리즘을 그대로 다시 써봤습니다.
(다음에 이런게 나오면 플로이드 와샬로....)

특별한 기술은 없지만 이 문제에 적합한 형태로 조금 변형했습니다.
큐에서 노드를 꺼낼때

if (cur == e) return distance;

이렇게 노드마다 검사를 하면서 목적지에 도착하면 바로 거리를 반환하는 그런 로직을 추가했습니다.
그리고 저 if문에 걸리지 않고 함수가 return되면 목적지로가는 길이 없다는 뜻이기에 -1을 return 했습니다.

CPP CODE

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

int N, M;
vector<vector<int>> graph;

int bfs(int s, int e) {
    vector<bool> visited(N + 1, false);

    queue<int> q;
    q.push(s);
    visited[s] = true;

    int distance = 0;
    while (!q.empty()) {
        int size = q.size();
        while (size--) {
            int cur = q.front();
            q.pop();

            if (cur == e) return distance;
            for (int v : graph[cur]) {
                if (!visited[v]) {
                    q.push(v);
                    visited[v] = true;
                }
            }
        }
        distance++;
    }

    return -1;
}

int main() {
    cin >> N >> M;

    graph = vector<vector<int>>(N + 1);
    for (int i = 1; i <= M; i++) {
        int a, b;
        cin >> a >> b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }

    int X, K;
    cin >> X >> K;

    int temp1 = bfs(1, K);
    int temp2 = bfs(K, X);
    if (temp1 == -1 || temp2 == -1) cout << "-1\n";
    else cout << temp1 + temp2;

    return 0;
}

[kangrae-jo]

오 이게 플로이드-와샬 알고리즘이군요 다음에는 이 알고리즘 써봐야겠네요...

[g0rnn]

저는 플로이드 와샬을 잘 몰라서 bfs를 사용하여 풀었습니다. 근데 풀이를 보니 만약 가중치가 모두 다른 값이 주어진다면 엄청 헤맸을 것 같네요..

기존 bfs로직에 새로운 걸 추가해야하나 생각했는데 구현하다 보니 하나의 bfs를 두번 사용하면 될거같다는 생각에 꽤나 금방 풀 수 있었던 문제였습니다.

다만 bfs 구현할 때 주의할 것이 같은 함수를 두번 사용하기에 visited와 queue를 새로운 매번 초기화해야 해서 그 부분이 조금 헷갈렸네요. 참고로 graph는 인접 리스트로 구현했습니다

int bfs(int start, int dest) {
    if (start == dest) return 0;

    int distance = 0;
    bool visited[101] = {false};
    queue<int> q;

    visited[start] = true;
    q.push(start);
    while (!q.empty()) {
        int size = q.size();
        while (size--) {
            int cur = q.front();
            q.pop();

            for (int adj: graph[cur]) {
                if (adj == dest) return ++distance;
                if (!visited[adj]) {
                    visited[adj] = true;
                    q.push(adj);
                }
            }
        }
        distance++;
    }
    return -1;
}

준용님과 다른 pr의 근호님 리뷰를 통해 플로이드 와샬을 배울 수 있었습니다. :) 다음 최단 경로 문제를 풀 때 써먹어야겠어요.

[kokeunho]

저번에 사용해본 플로이드-와샬 알고리즘을 다시 활용해볼 수 있는 문제였습니다.
코드는 동일합니다.
이번 PR도 수고하셨습니다~

Java code

    import java.util.*;

    public class Main {
    static int INF = (int) 1e9;
    static int[][] graph;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int M = sc.nextInt();

        graph = new int[N+1][N+1];
        for (int i = 0; i <= N; i++) {
            Arrays.fill(graph[i], INF);
            graph[i][i] = 0;
        }
        for (int i = 0; i < M; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();

            graph[a][b] = 1;
            graph[b][a] = 1;
        }

        int X = sc.nextInt();
        int K = sc.nextInt();

        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                for (int k = 1; k <= N; k++) {
                    graph[i][j] = Math.min(graph[i][j], graph[i][k] + graph[k][j]);
                }
            }
        }

        int result = graph[1][K] + graph[K][X];

        if (result >= INF) {
            System.out.println(-1);
        } else {
            System.out.println(result);
        }
    }
}