33-g0rnn

[g0rnn]

🔗 문제 링크

트리의 지름

✔️ 소요된 시간

1h

✨ 수도 코드

사실 한시간 까진 걸리진 않고, 솔루션을 생각만 한다면 금방 풀 수 있는 문제입니다.

우선 오해하면 안될것이 "트리의 개념"입니다. 트리는 어떤 조건을 가진 그래프입니다.

1. 간선의 개수는 N-1개
2. 사이클이 없음
3. 따라서 임의의 두 노드 간 경로는 오직 하나!

이 사실을 깨닫는다면 솔루션이 꽤나 쉽게 떠오를지도 모릅니다.

문제를 푸는 방법은 일단 임의의 노드로부터 가장 먼 거리의 노드를 찾습니다. 그리고 그 노드로부터 다른 노드까지의 거리 중 가장 큰 값을 찾는거죠.

그림을 보면 좀 더 쉽게 이해가 가능합니다. 임의의 노드로부터 가장 멀리 떨어져있는 노드는 단 1개 입니다. 이 5번 노드로부터 가장 멀리 떨어져있는 노드를 찾으면? 그건 트리의 지름이 되겠죠.

📚 새롭게 알게된 내용

dfs로 방문할 때 미리 visited = true로 설정하면 안된다!!

제가 1시간이나 써버린 이유입니다. visited를 노드에 방문하기전 true로 설정하면 다음 노드를 방문할 때 문제가 발생할 수도 있습니다. 직관적인 이해가 되진 않으나 예전에도 같은 문제로 시간을 썼던 기억이 납니다. 조심하시길 바랍니다.!

private static void dfs(int node, int len) {
        if (len > max) {
            max = len;
            endNode = node;
        }
        for (int[] next : tree.get(node)) {
            if (visited[next[0]]) continue;
            visited[next[0]] = true;
            dfs(next[0], len + next[1]);
        }
    }

위처럼 dfs를 실행하기 전 visited = true로 돌리면 위험합니다! 이 문제에서 방문 표시를 dfs전에 하고 싶다면 max 값을 두번째 dfs실행하기 전에 초기화해주면 됩니다. 궁금하다면 아래 코드를 참고해보세용

warning

import java.io.*;
import java.util.*;

public class Main {

    static int v;
    static List<List<int[]>> tree = new ArrayList<>();
    static int endNode, max = -1;
    static boolean[] visited;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        v = Integer.parseInt(br.readLine());
        for (int i = 0; i <= v; i++) {
            tree.add(new ArrayList<>());
        }
        for (int i = 0; i < v; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int cur = Integer.parseInt(st.nextToken());
            while (true) {
                int u = Integer.parseInt(st.nextToken());
                if (u == -1) break;
                int cost = Integer.parseInt(st.nextToken());
                tree.get(cur).add(new int[]{u, cost});
            }
        }
        br.close();

        visited = new boolean[v + 1];
        visited[0] = true;
        //max = -1;
        dfs(1, 0);

        visited = new boolean[v + 1];
        visited[endNode] = true;
        max = -1;
        dfs(endNode, 0);

        System.out.println(max);
    }

    private static void dfs(int node, int len) {
        if (len > max) {
            max = len;
            endNode = node;
        }
        for (int[] next : tree.get(node)) {
            if (visited[next[0]]) continue;
            visited[next[0]] = true;
            dfs(next[0], len + next[1]);
        }
    }
}

[kokeunho]

트리의 지름을 찾는 법을 배울 수 있었습니다.

임의의 정점에서 가장 먼 지점을 찾은 후,
그 지점에서 가장 먼 지점까지의 거리가 지름이 된다는 것을 알게 되었습니다.
직관적으로 이해가 되지 않아 납득하는데 시간이 좀 걸렸네요.

저의 처음 풀이는 (방향 그래프는 아니지만) 정점마다 진입 간선의 수를 세고
가장 많은 진입 간선을 가진 정점에서
가장 먼 거리와 두 번째로 먼 거리를 합하면 지름이 되지 않을까 생각하여 풀었습니다.

뭔가 애매하다고 생각은 했지만
예시 입력에 대해서 정답의 출력이 나오길래 맞는 줄 알았습니다.

하지만 이런 경우 가장 먼 노드까지의 경로와 두 번째로 먼 노드까지의 경로가
서로 다른 방향으로 뻗어가는 경로라는 보장이 없기 때문에 예외 상황이 발생합니다.

수고하셨습니다!

Details

import java.io.*;
import java.util.*;

public class Main {
    static int V;
    static List<List<Node>> graph;
    static class Node {
        Integer next;
        Integer weight;

        Node(int next, int weight) {
            this.next = next;
            this.weight = weight;
        }
    }

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        V = Integer.parseInt(br.readLine());
        graph = new ArrayList<>();

        for (int i = 0; i <= V; i++) {
            graph.add(new ArrayList<>());
        }

        for (int i = 0; i < V; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());

            int idx = Integer.parseInt(st.nextToken());

            while (true) {
                int next = Integer.parseInt(st.nextToken());
                if (next == -1) break;
                int weight = Integer.parseInt(st.nextToken());
                graph.get(idx).add(new Node(next, weight));
            }
        }

        int[] dist1 = bfs(1);

        int maxPath = 0;
        int startOfDiameter = 1;
        for (int i = 2; i <= V; i++) {
            if (dist1[i] > maxPath) {
                maxPath = dist1[i];
                startOfDiameter = i;
            }
        }

        int[] dist2 = bfs(startOfDiameter);

        int answer = 0;
        for (int i : dist2) {
            answer = Math.max(answer, i);
        }

        System.out.print(answer);
    }
    static int[] bfs(int idx) {
        int[] dist = new int[V+1];
        Arrays.fill(dist, -1);

        Queue<Integer> queue = new LinkedList<>();
        queue.add(idx);
        dist[idx] = 0;

        while (!queue.isEmpty()) {
            int current = queue.poll();
            for (Node v : graph.get(current)) {
                int nextNode = v.next;
                if (dist[nextNode] == -1) {
                    queue.add(nextNode);
                    dist[nextNode] = dist[current] + v.weight;
                }
            }
        }

        return dist;
    }
}

[9kyo-hwang]

오흠씨 알고리즘 수업 들을 때, 그룹 액티비티 문제로 내셔서 설명 들었던 기억이 있네요. 물론 그때는 이해 못했지만...

1. 아무 노드(보통 루트)를 잡고 DFS -> 가장 먼 노드 획득
2. 가장 먼 노드 기준으로 다시 DFS -> 다시 가장 먼 노드 획득
3. 두 가장 먼 노드 간 길이가 트리의 지름

요 아이디어만 숙지하고 있다면 구현은 나름 간단하게 할 수 있는 것 같네요 :) 1967 트리의 지름 똑같은 문제니까 점수 날먹하십쇼 ^^7

#include <iostream>
#include <vector>

using namespace std;
using pii = pair<int, int>;

int V;
vector<vector<pii>> tree;
vector<bool> visited;
int max_node = 0, max_dist = 0;

void dfs(int from, int total_dist = 0) {
  visited[from] = true;

  if (total_dist > max_dist) {
    max_node = from;
    max_dist = total_dist;
  }

  for (const auto &[to, distance] : tree[from]) {
    if (!visited[to]) {
      dfs(to, total_dist + distance);
    }
  }
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  
  cin >> V;
  tree.resize(V + 1);

  for (int i = 1; i <= V; ++i) {
    int src_num;
    cin >> src_num;

    int dst_num, dst_dist;
    while (cin >> dst_num && dst_num != -1) {
      cin >> dst_dist;
      tree[src_num].emplace_back(dst_num, dst_dist);
    }
  }

  visited.assign(V + 1, false);
  dfs(1);
  visited.assign(V + 1, false);
  dfs(max_node);

  cout << max_dist;
  
  return 0;
}

[kangrae-jo]

트리의 지름을 구하는 방법을 알고있어도 어렵네요.
50분 정도 걸렸습니다.

처음에 어떤 노드로 부터 가장 먼 노드를 찾고,
그 노드에서 가장 먼 노드까지의 가중치가 트리의 지름이죠.

처음 노드를 찾을때, 그 노드를 저장하는 방식을 생각해봤는데,
저는 solution 함수에서 리턴을 해버리게 하고 싶어서 pair<int,int> 로 두고 weight와 endnode로서 활용했습니다.

그 과정에서 endnode 를 = 0 으로 초기화 해버리는 잘못을 해서 한 10분 이상 날린 것 같네요.
좋은 문제 감사합니다.

그리고 방문처리를 for문 밖에서 해야하는 이유는 정확히 모르겠지만...
아마 if(len> max)이 로직이 for문 밖에 있어서 그런거 아닐까요.
메서드가 int를 리턴하게 하면 문제가 없을 것 같아요 (해보지는않음)

#include <iostream>
#include <vector>

using namespace std;

int V;
vector<vector<pair<int, int>>> graph;

pair<int,int> solution(vector<bool>& v, int cur) {
    int answer = 0;
    int node = cur;

    for (auto [next, w] : graph[cur]) {
        if (v[next]) continue;
        v[next] = true;

        auto [candiW, candiN] = solution(v, next);
        if (answer < candiW + w) {
            answer = candiW + w;
            node = candiN;
        }
    }
    return {answer, node};
}

int main() {
    cin >> V;

    graph = vector<vector<pair<int, int>>>(V + 1);
    for (int i = 1; i <= V; i++) {
        int a, b, w;
        cin >> a;

        while (cin >> b && b != -1) {
            cin >> w;
            graph[a].push_back({b, w});
            graph[b].push_back({a, w});
        }
    }

    vector<bool> visited(V + 1, false);
    visited[1] = true;
    auto [weigth, node] = solution(visited, 1);

    visited.assign(V + 1, false);
    visited[node] = true;
    cout << solution(visited, node).first;

    return 0;
}