12-g0rnn

[g0rnn]

🔗 문제 링크

회장뽑기
영광의 2025 첫 & 50번째 pr은 제가 가져갑니다^^

✔️ 소요된 시간

30m

✨ 수도 코드

문제를 간단히 요약하면 동아리원의 관계를 그래프로 나타내고 각 노드를 기준으로 순회하며 얼마나 깊은 연결을 가지는지를 출력하는 문제입니다.

1. 먼저 동아리원을 그래프로 나타냅니다. 저는 2차원 배열을 사용하여 간단하게 그래프를 구현하였습니다.

2. bfs를 사용하여 각 노드(모든 동아리원)를 root로 설정하여 얼마나 깊은 연결을 가지는지 확인하고 level을 return 합니다. 이 부분도 어렵지 않을 겁니다. 만약 어렵다면 예전 토마토 문제를 확인하길...

// 저는 다음과 같이 구현했습니다.
for (int i = 1; i <= n; i++) {
    int score = bfs(i);
    ...
}

3. 점수가 가장 낮은 것들만 추리고 정답을 출력한다.

이 문제를 푸는데 bfs를 사용한다고 인지하고 구현하는 것은 쉽다고 생각하지만 2~3번으로 넘어가는 단계를 구현하는 것이 제일 난관이라 예상됩니다.

저는 처음에 모든 노드를 bfs로 순환하고 return 값을 priority_queue(최소 우선순위 큐)에 삽입하여 자동으로 정렬하고 front와 같은 point를 가진 요소들을 빼내어 정답을 출력하려 했습니다.

근데 무슨 이유에선지 메모리 초과가 뜨더군요.. gpt를 통해 알아낸 결과 priority_queue에 데이터를 추가할 때 힙의 성질을 유지하기 위해 요소들이 재배치 되고 내부적으로 size가 늘어날 때마다 2배로 늘어나니 이 때 메모리가 초과될 수 있다고 하더군요.

cpp에서 동적 배열이란 배열의 size가 내가 넣은 원소만큼 늘어났다 줄어드는 것처럼 보이지만 실제 내부적으로는 정해진 size가 있고 이를 초과할 때마다 new를 통해 더 큰 size의 배열을 만들고 기존 배열을 삽입하게 됩니다. 이 때 잠깐이나마 배열이 두개나 생기게 되니 메모리가 초과될 수 있다고 하더군요. (근데 아무리 그래도 n이 50인데 128MB 보다 커질 수 있을까요?)

그래서 방법을 바꾸어 bfs를 통해 return 받은 값 중 작은 값을 기록한 후 값을 비교하여 의미있는 값들만 추려낸 후 정답을 출력하였습니다.

📚 새롭게 알게된 내용

주석 부분은 제가 처음 생각해낸 코드인데 메모리 초과가 발생하는 이유가 완벽히 납득되지 않아 의견을 듣고 싶어 남겨 두었습니다.

그리고 auto [point, who]를 보면 알 수 있는 cpp에서도 파이썬처럼 두가지 값을 동시에 받을 수 있더군요. cpp17부터 생겼다고 합니다. std::tuple, std::pair과 같은 것에 사용할 수 있대요!!

[kangrae-jo]

이 문제를 푸는 아이디어로 다음과 같은 솔루션이 떠올랐습니다.

1. 모든 사람을 시작점으로하는 bfs 진행.
2. 1번 진행중 모든 노드가 방문되었다면 가장 멀리있는 노드까지의 거리 저장
3. 가장 멀리있는 노드까지의 거리들 중 가장 짧은 것 찾기

처음에는 균호님 코드처럼 1씩 거리를 증가시키며 bfs를 했는데 계속 4%에서 틀렸다고 뜨더군요,,
그래서 gpt선생님의 도움을 받았습니다.

return *max_element(distances.begin(), distances.end());

이렇게 distance배열에 거리들을 저장하고 가장 큰값을 리턴하도록 수정했습니다.

원래 코드

int bfs(vector<list<int>>& graph, int member) {
    vector<bool> visited(N + 1, false);
    queue<int> q;
    q.push(member);
    visited[member] = true;

    int distance = 0;
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            int cur = q.front();
            q.pop();
            for (int curFriend : graph[cur]) {
                if (!visited[curFriend]) {
                    q.push(curFriend);
                    visited[curFriend] = true;
                }
            }
        }
        distance++;
    }

    if (isConnected(visited)) return distance;
    return -1;
}

(저도 왜 그래야했는지 정확한 이유는... 모르겠더라고요.. 계속 알아보는 중입니다.)

그리고 나머지 부분은 균호님과 비슷합니다.
최종 배열에 최단거리 값들만 남기고 그것들을 올바르게 출력하는 방식으로 진행했습니다.

CPP CODE

#include <iostream>
#include <list>
#include <queue>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int N;

void printResult(vector<pair<int, int>>& result) {
    cout << result[0].first << " " << result.size() << '\n';
    for (auto& p : result) cout << p.second << " ";
}

int bfs(vector<list<int>>& graph, int member) {
    vector<bool> visited(N + 1, false);
    vector<int> distances(N + 1, 0);
    queue<int> q;
    q.push(member);
    visited[member] = true;

    while (!q.empty()) {
        int cur = q.front();
        q.pop();

        for (int curFriend : graph[cur]) {
            if (!visited[curFriend]) {
                q.push(curFriend);
                visited[curFriend] = true;
                distances[curFriend] = distances[cur] + 1;
            }
        }
    }

    if (find(visited.begin() + 1, visited.end(), false) != visited.end()) return -1;
    return *max_element(distances.begin(), distances.end());
}

int main() {
    cin >> N;

    vector<list<int>> graph(N + 1);
    while (true) {
        int a, b;
        cin >> a >> b;
        if (a == -1 && b == -1) break;

        graph[a].push_back(b);
        graph[b].push_back(a);
    }

    vector<pair<int, int>> result;
    int minDistance = INT_MAX;
    for (int i = 1; i <= N; i++) {
        int distance = bfs(graph, i);
        if (distance == -1) continue;
        if (distance < minDistance) {
            result.clear();
            minDistance = distance;
        }
        if (distance == minDistance) result.emplace_back(minDistance, i);
    }

    if (!result.empty()) printResult(result);

    return 0;
}

cpp 쓰시는 분은 코드 한 번 잘 읽어보시면 도움이 될 것 같습니다.
지금까지 저는 잘 안써왔던 find 와 max_element 등을 활용해보았습니다!!
(그리고 emplace_back도 처음 활용해보았습니다.)

---

그리고 균호님이 작성하신 priority_queue를 사용하는 방식도 많이 고민해봤습니다.
그런데.. 메모리 초과가 나는 이유는 찾지 못했습니다...

저도 균호님 설명처럼 동적 배열인 벡터가 늘어나도 128MB를 초과할 정도인지 잘 가늠이 안되네요..
조금 더 알아보겠습니다.

이번 pr은 생각해볼 거리가 많은 것 같네요
좋은 문제 감사합니다 ! !

[kangrae-jo]

왜 메모리 초과가 나는지 아직 잘 모르겠네요...
좀 오래 고민했는데도 답이 없네요

메모리 초과가 아니라면 좋은 로직인 것 같아요!

[g0rnn]

혹시 처음 코드에서도 main함수는 변함이 없나요? 저도 왜 안되는지 이유를 생각해봤는데 함수는 잘작동하는 것처럼 보이고 제 코드랑 거의 같은거 같아서 main에서의 오류가 아닌가 생각되네요

[kangrae-jo]

아... 출력을 잘못했네요...
제일 첫 출력이 회장 후보 점수인데 저는 회장 후보 중 가장 첫 녀석을 출력하고 있었네요.
( 테스트 케이스에서는 둘다 2, 2 라서 발견이 안됐네요)

[kangrae-jo]

오 그리고 균호님 우선순위 큐 버전의 솔루션도 이유를 찾았습니다!!

다른 곳 하나도 안건들였고, 문제는 여기였습니다.

while (!candidate.empty() && candidate.top().first == point) {
    president.push_back(candidate.top().second);
    candidate.pop();
}

candidate가 비어있는 경우를 커버하지 못해서 무한루프에 빠졌었기 때문에 메모리 초과가 발생했던 것이네요

테스트 케이스는 다음과 같습니다.

2
1 2
-1 -1

[g0rnn]

아니 이런 실수를.. 해당 부분은 틀렸을거라 생각도 안한 부분이라 혼자였다면 절대 못찾았을 겁니다ㅜㅜ 찾아주셔서 감사합니다 :)

[wnsmir]

문제를 읽다보니 BFS문제임을 알 수 있었습니다.

3명이라면 첫사람부터 돌아가며 나머지 두사람과의 관계에서 얼마나떨어져있는지 알기위해 BFS를 사용하면 되겠다 싶었습니다.

예를들어 친구의 친구가 아닌 직접적 친구면 BFS 1회에 친구노드가 잡힐것입니다.

그리고 만약 모두가 직접적인 친구라면, 첫 BFS에 모든 노드들이 다 들어와야겠죠.

이를 각 노드들간의 거리로 판단해 전부 1이라면 해당노드는 1점으로 가장 낮은 점수를 받게 됩니다.

from collections import deque

N = int(input())
friends = [[]for _ in range(N+1)]

while True:
    a, b = map(int, input().split())
    if a== -1 and b == -1:
        break
    friends[a].append(b)
    friends[b].append(a)

def bfs(start):
    dist = [-1] * (N + 1)
    dist[start] = 0
    queue = deque([start])
    
    while queue:
        current = queue.popleft()
        for neighbor in friends[current]:
            if dist[neighbor] == -1:
                dist[neighbor] = dist[current] + 1
                queue.append(neighbor)
    return dist
    
scores = []
for i in range(1, N + 1):
    dist = bfs(i)
    max_dist = max([d for d in dist[1:] if d != -1])
    scores.append((i, max_dist))

min_score = min(score for _, score in scores)
candidates = [member for member, score in scores if score == min_score]

print(min_score, len(candidates))
print(*sorted(candidates))

추가사항
파이썬에서 print(*sorted())를 사용하게 되면 리스트안의 내용을 공백기준으로 풀어서 출력해줍니다.

max_dist = max([d for d in dist[1:] if d != -1])는 리스트컴프리헨션이란 문법입니다.
즉 0번째 인덱스를 제외하고 1부터 끝까지 리스트에서 가져옵니다. 다만 if문으로 -1이 아닌값만 가져옵니다. 문제에서 어떻게든 다 아는 사이라 했으니 사실 필요없는 부분이긴 합니다,,

[kokeunho]

풀이를 찾아보니 플로이드-워셜 알고리즘을 사용한 풀이가 있더군요.
다들 BFS로 풀었기에 플로이드-워셜을 대충 공부하고 풀어봤습니다.
플로이드-워셜 알고리즘의 사용 목적은 모든 정점 쌍 간의 최단 경로를 계산하는 것입니다.
그에 반해 BFS는 특정 정점에서 다른 정점들까지의 경로이므로 모든 정점에서 BFS를 실행해야 합니다.
해당 문제에서 플로이드-워셜은 O(v^3) (v는 정점의 개수), BFS는 O(v * (v + E))의 시간 복잡도를 가집니다.
정점의 수가 적을 때는 플로이드-워셜도 괜찮으나 사실 BFS를 사용하는 것이 대부분의 상황에서 좋다고 하는 것 같습니다.

java code

        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
        int[] scores = new int[n+1];
        int min = INF;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                scores[i] = Math.max(scores[i], dist[i][j]);
            }
            min = Math.min(min, scores[i]);
        }

중간 노드 k를 추가해가며 i에서 j로 가는 최단 거리를 갱신합니다.

scores[i]에는 dist[i]에서의 최대값을 넣습니다.
socres[] 중 최소값을 찾습니다. 이 값이 후보가 될 회원들의 점수입니다.

다들 이미 플로이드-워셜 알고리즘에 대해 알고있겠지만 그냥 저를 위해 끄적여봤습니다. 균호님 이번 PR도 수고 많으셨습니다!