22-hyeokbini

[hyeokbini]

🔗 문제 링크

골드 4
차량 배치

✔️ 소요된 시간

2시간

✨ 수도 코드

우선 자력솔은 실패했습니다. 방향성을 잘못 잡았던 게 크게 굴러갔네요. 블로그의 풀이를 보고 아이디어를 얻어서 구현했습니다.

문제에서 요구하는 내용은 차량이 각 지점에 다양한 경우의 수로 들어가 있고 도로를 따라 최대한 낮은 번호의 지점으로 동시에 이동할 때, 충돌(한 지점에 2개 이상의 차량이 들어감) 이 일어나지 않고 모든 차량이 1번 지점을 통해 밖으로 나갈 수 있는 차량 배치 경우의 수를 구할 것을 요구합니다.

실패 아이디어

첫 아이디어는 조합 + 시뮬레이션을 통해 실제 차량을 배치한 뒤, 모든 차량을 뺄 수 있는지를 탐색했습니다.

차량 배치 / 실패

#include <bits/stdc++.h>

using namespace std;

int n, m;
vector<vector<int>> arr;
int ans = 0;

vector<bool> caruse;
queue<int> Q;

void check(const vector<int> &car)
{
    caruse.assign(n, false); 
    Q = {};
    for (int i = 0; i < (int)car.size(); i++)
    {
        caruse[car[i]] = true;
        Q.push(car[i]);
    }
    while (!Q.empty())
    {
        int T = Q.size();
        while (T--)
        {
            int curcaridx = Q.front();
            Q.pop();
            if (curcaridx == 0)
            {
                caruse[0] = false;
                continue;
            }
            if (arr[curcaridx].empty())
            {
                return;
            }

            int nxt = arr[curcaridx][0];

            if (caruse[nxt])
            {
                return;
            }

            caruse[curcaridx] = false;
            caruse[nxt] = true;
            Q.push(nxt);
        }
    }
    ans++;
    return;
}

void func(vector<int> &car, int depth)
{
    if (depth == n)
    {
        return;
    }
    for (int i = depth; i < n; i++)
    {
        car.push_back(i);
        check(car);
        func(car, i + 1);
        car.pop_back();
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    freopen("test.txt", "rt", stdin);
    cin >> n >> m;
    arr.resize(n, vector<int>());
    for (int i = 0; i < m; i++)
    {
        int a, b;
        cin >> a >> b;
        int start = max(a, b);
        int dest = min(a, b);
        arr[start - 1].push_back(dest - 1);
    }
    for (int i = 0; i < n; i++)
    {
        sort(arr[i].begin(), arr[i].end());
    }

    caruse.assign(n, false);

    vector<int> car;
    func(car, 0);
    cout << ans % 1000000007;
    return 0;
}

하지만 몇 번 시도해봤을 때, 메모리 초과랑 시간 초과를 먹었습니다.

어떻게 보면 당연한 결과인데, 입력으로 주는 노드 / 간선의 개수가 최대 20만입니다. 따라서 이런 브루트포스 형식으로는 절대 시간 내에 통과할 수 없습니다.

핵심 아이디어에 대해 갈피를 못 잡고 고민하다가 결국 풀이를 확인했습니다.

---

성공 아이디어

문제를 잘 이해해 본다면, 핵심적으로 처리해야 하는 부분은 차량 충돌에 관한 부분입니다.
차량이 움직이는 패턴은 정해져 있습니다. 갈 수 있는 도로들 중 가장 번호가 낮은 지점으로 이동하고, 모든 차량은 동시에 이동합니다.

이를 거꾸로 생각한다면 루트 노드(1번 지점) 에서 특정한 차량의 깊이를 계산한 후, 깊이가 중복되는 차량이 있다면 결국 1번 지점에서 충돌하기 때문에 한 레벨에서 하나의 차량을 뽑는 경우의 수를 모든 레벨에 진행한 뒤, 곱셈을 통해 해결하는 아이디어를 얻을 수 있습니다.

이미지 출처 : https://untitledtblog.tistory.com/85

위 이미지처럼 그래프가 형성된다면 A / B,C / D,E,F가 같은 레벨이고, 이렇게 나뉜 목록들에서 중복된 레벨에 대해 2개 이상의 차량을 뽑으면 충돌이 일어납니다.

간단히 예시로 D / F의 경우를 생각해 보더라도 A(1번 도착지점)에서 충돌이 일어납니다. 같은 레벨에 대해 어떠한 조합을 뽑아도 무조건 충돌이 일어남을 알 수 있습니다.

따라서 레벨을 구한 뒤, 각 레벨의 차량 개수 + 1(아예 선택하지 않는 수) 를 구하고, 이 경우의 수들은 모두 독립적이므로 전부 곱해주면 가능한 모든 경우의 수를 구할 수 있습니다.

📚 새롭게 알게된 내용

그래프 이론에 중점을 둔 문제일 줄 알았는데, 개인적으로는 애드혹...? 감성도 섞여 있는 것 같습니다. 깊이라는 개념을 생각하고 그걸 이용해 답을 도출하는 아이디어를 떠올리지 못한다면 갈피를 잡기 어려웠던 문제 같습니다.

[flydongwoo]

저도 자력솔은 실패했습니다
골드는 역시 골드답네요 ,,,

일단 BFS로 풀어야한다는 것은 찾은 상태였습니다

코드 공유 드립니다. 문제 푸느라 고생하셨어요~!

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

static const long long MOD = 1000000007LL;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, M;
    cin >> N >> M;

    vector<vector<int>> g(N + 1);
    for (int i = 0; i < M; i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    vector<int> dist(N + 1, -1);
    queue<int> q;

    dist[1] = 0;
    q.push(1);

    int maxDepth = 0;

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (size_t i = 0; i < g[u].size(); i++) {
            int v = g[u][i];
            if (dist[v] == -1) {
                dist[v] = dist[u] + 1;
                if (dist[v] > maxDepth) {
                    maxDepth = dist[v];
                }
                q.push(v);
            }
        }
    }

    vector<long long> cnt(maxDepth + 1, 0);
    for (int i = 1; i <= N; i++) {
        if (dist[i] != -1) {
            cnt[dist[i]]++;
        }
    }

    long long ways = 1;
    for (int d = 0; d <= maxDepth; d++) {
        ways = (ways * ((cnt[d] + 1) % MOD)) % MOD;
    }

    ways = (ways - 1 + MOD) % MOD; 
    cout << ways << endl;
    return 0;
}

[Seol-Munhyeok]

같은 레벨에 있는 노드끼리는 반드시 충돌이 발생한다. 라는 발상이 알고나면 당연한 것처럼 생각되는데 처음부터 이 발상을 한다는게 어려운 문제였습니다.
일단 첫 번째 예시 같은 경우

        1
      /
    2
  /
3

이런 그래프니까 $2 \times 2 \times 2 - 1$ 해서 7이네 하는 생각이 들긴 했습니다.
결국 그 의미가 각 레벨에 노드가 1개씩 있으니까 그렇게 나온 거네 하고 나중에 알게되었습니다.

코딩테스트 문제를 풀 때 가장 중요한 수학 지식은 '확률과 통계'에서 배운 지식 같습니다.
흔히 '조합론'이라고 불리는 유형도 많이 풀어봐야할 거 같습니다.

풀이 : http://boj.kr/842a576a84e546cc8b274159dedc2a96

수고했습니다!!!!

[mj010504]

저도 처음에 조합 + 최단 경로를 미리 시뮬레이션 해논 결과로 풀려다가 아무래도 시간 초과가날 것 같은 느낌이 강해서 풀이 참고했습니다. 충돌을 발생시키지 않기 위해 트리의 깊이를 생각해내는 것이 쉽지 않아보이네요. 풀이를 생각해내기 까지가 어려운 문제인 것 같습니다. 수고하셨습니다.
여담으로 정점 개수가 20만개로 많아서 인접리스트 말고 2차원 벡터로 풀었다가 메모리 초과가 한 번 났습니다 :(

차량 배치

#include <bits/stdc++.h>

using namespace std;

#define N 1000000007

int main() {
    // freopen("input.txt", "rt", stdin);  
    ios::sync_with_stdio(false);  
    cin.tie(0);
    cout.tie(0);
 
    int n, m; cin >> n >> m;
    vector<vector<int>> adj(n);

    for(int i = 0; i < m; i++) {
        int a, b; cin >> a >> b;
        a--; b--;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }

    vector<bool> visited(n, false);
    visited[0] = true;

    map<int, int> depth;
    depth[0] = 1;

    queue<pair<int, int>> q; q.push({0, 0});
    while(!q.empty()) {
        auto tp = q.front(); q.pop();
        for(auto idx : adj[tp.first]) {
            if(!visited[idx]) {
                visited[idx] = true;
                depth[tp.second + 1] += 1;
                q.push({idx, tp.second + 1});
            }
        }
    }

    long long res = 1;
    for(auto d : depth) {
        res = res * (d.second + 1) % N;
    }

    cout << res - 1;
  

    return 0;
}