30-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ] 중량제한 https://www.acmicpc.net/problem/1939

✔️ 소요된 시간

1h

✨ 수도 코드

어제 오랜만에 다익스트라 문제를 풀고
비슷한 유형으로 풀어보려고 고른 문제인데
일반적인 다익스트라랑 달라서 몇번 실패하고
결국 풀이를 참고해서 이분 탐색 + bfs 풀이로 풀어서 가져왔습니다.
(다익스트라로 다시 풀어서 해결했습니다만 이번 풀이가 더 좋아보여서 해당 풀이로 작성합니다.)

bfs 메서드는 A에서 B까지 mid 중량을 실은채로 갈 수 있는지 여부를 확인하는 것입니다.
이때 mid 중량을 이분 탐색을 통해 결정합니다.

막상 수도 코드 쓰려니 쓸게 없네요. 이상입니닷.

📚 새롭게 알게된 내용

[wnsmir]

오랜만에 노드 간선유행의 bfs를만나 반가웠습니다!

먼저 문제를보고 최대값을 찾으라해서 dfs로 모든경우의수를 다 체크해보고 최대값을 찾아보려 했지만 최대값이 10억인걸보고 이분탐색을 써야하나? 라는 생각을 했습니다.

다만 이를 이분탐색으로 최대값을 정하고, 직접 bfs로 대입해보는 구조로 풀 생각을 하기까지는 시간이 좀 걸렸던것 같습니다.

문제가 어느정도 쉬웠던 이유는 시작지점과 끝지점을 이미 정해주었기때문에 bfs를 돌릴떄는 사실 가중치만 넣어주면 됐었기 때문입니다.

사실 이부분이 쉬우면서도 시간을 많이 잡아먹었는데, bfs는보통 간선의 가중치가 없을떄 사용하지만, 이문제는 visited조건 이외에도 가중치를 버틸수 있는지의 조건을 더해 bfs경로를 중간에 차단할 수 있어야 했기 떄문입니다.

신박한 문제 잘보고갑니다!

import sys
from collections import deque

N, M = map(int, input().split())
edges = [[] for _ in range(N+1)]
for _ in range(M):
    a, b, c = map(int, input().split())
    edges[a].append((b, c))
    edges[b].append((a, c))
start, end = map(int, input().split())

def bfs(weight):
    visited = [False] * (N+1)
    queue = deque()
    queue.append(start)
    visited[start] = True

    while queue:
        now = queue.popleft()
        if now == end:
            return True
        for next, limit in edges[now]:
            if not visited[next] and limit >= weight:
                visited[next] = True
                queue.append(next)
    return False

left = 1
right = 1_000_000_000
answer = 0

while left <= right:
    mid = (left + right) // 2
    # 가능할때
    if bfs(mid):
        # 오른쪽 구간에서 다시 이분탐색
        answer = mid
        left = mid + 1
    # 불가능하다면
    else:
        #왼쪽구간에서 다시 이분탐색
        right = mid - 1

print(answer)

아 참고로 파이선은 정수 중간에 언더바를 사용하여도 전혀 문제되지 않습니다!
1_000_000_000 == 1000000000

[kangrae-jo]

처음에 무지성으로 그냥 다익스트라 돌렸다가 틀렸네요.
저는 난독증이 있나봅니다.
문제 이해가 한 번에 안되네요..

그치만 어려운 문제는 아니었다고 생각합니다.
말씀하신 대로 이분탐색으로 최적해를 찾는 문제인데,
아마 이전에 저희가 좀 했던 파라메트릭 서치라고 부를 수 있을 것 같아요.

뭔가 한 번의 bfs 만에 's에서 e 까지 가중치 중에 가장 작은 녀석'을 찾는 방법을 생각해보려고 했는데..
틀렸네요.. 발견한 가장 작은 가중치를 지나지 않고도 도시에 도착할 수 있는 경우의 수 도 고려해야하기 때문에 어려운 방식같네요. 슬픕니다.

좋은 문제 감사합니다.

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

using namespace std;

bool solution(const vector<vector<pair<int, int>>>& graph, int m, int s, int e) {
    vector<bool> visited(graph.size(), false);
    queue<int> q;
    q.push(s);
    visited[s] = true;

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

        if (cur == e) return true;

        for (auto [next, dist] : graph[cur]) {
            if (!visited[next] && dist >= m) {
                visited[next] = true;
                q.push(next);
            }
        }
    }
    
    return false;
}

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

    vector<vector<pair<int, int>>> graph(N + 1);
    while (M--) {
        int A, B, C;
        cin >> A >> B >> C;
        graph[A].push_back({B, C});
        graph[B].push_back({A, C});
    }

    int s, e;
    cin >> s >> e;

    long long start = 1, end = 1000000000;
    while (start <= end) {
        long long mid = (start + end) / 2;
        if (solution(graph, mid, s, e)) start = mid + 1;
        else end = mid - 1;
    }

    cout << end;

    return 0;
}

[9kyo-hwang]

BFS/Dijkstra라는 생각이 처음 딱 들어서 우당탕탕 짰는데, 이게 실시간으로 최대 중량을 업데이트 하는 방법이 안떠오르더라구요. 그래서 골머리 싸매다가, 입력으로 주어지는 최대 중량이 10억으로 큰 거 보고 "뭔가 이진탐색 깔이 보이는데"라는 생각이 들어서 아예 이진탐색으로 기준 중량을 잡고, 그 중량값으로 목적지에 도달할 수 있는 지에 따라 기준 중량값을 조절하며 최대값을 갱신하는 식으로 하니까 맞더라구요. 약간 발상의 전환(?)

이진탐색

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, M;
    cin >> N >> M;
    
    int maxWeight = 0;
    vector<vector<pair<int, int>>> graph(N + 1);
    while(M--) {
        int A, B, C;
        cin >> A >> B >> C;
        
        graph[A].emplace_back(B, C);
        graph[B].emplace_back(A, C);
        
        maxWeight = max(maxWeight, C);
    }
    
    int src, dst;
    cin >> src >> dst;
    
    auto Check = [&](const int stdLimit) {
        queue<int> q;
        q.emplace(src);
        
        vector<bool> visited(N + 1, false);
        visited[src] = true;
        
        while(!q.empty()) {
            const int u = q.front();
            q.pop();
            
            if(u == dst) {
                return true;
            }
            
            for(const auto& [v, limit] : graph[u]) {
                if(!visited[v] && limit >= stdLimit) {
                    visited[v] = true;
                    q.emplace(v);
                }
            }
        }
        
        return false;
    };
    
    int ans = 0;
    int lo = 1, hi = maxWeight;
    while(lo <= hi) {
        int mid = (lo + hi) / 2;
        if(Check(mid)) {
            ans = max(ans, mid);
            lo = mid + 1;
        } else {
            hi = mid - 1;
        }
    }
    
    cout << ans;
    
    return 0;
}

그런데 뭔가 실시간으로 최대 중량을 업데이트 할 수 있을 것 같다는 생각이 자꾸 들어서 다른 사람 풀이를 봤는데, 최소 스패닝 트리 기법을 사용하면 이게 가능해서 이것도 들고왔습니다 ㅎ

스패닝 트리를 구축할 때, 보통은 간선의 가중치가 작은 순으로 정렬하지만 여기서는 거꾸로 가중치가 큰 것을 기준으로 정렬합니다. 우리의 목적이 가중치가 가장 큰 값을 찾는 거니까요.

그리고 간선들에 대해 Union을 수행합니다. 가중치가 큰 간선들 먼저 Union되겠죠? 그러면 어느 순간 출발 공장 노드와 도착 공장 노드가 연결되는(두 노드의 부모가 같은) 순간이 옵니다. 그러면 그 때 확인하는 간선의 가중치를 출력하면 됩니다. 두 공장이 연결되는 순간의 경로가 가장 큰 하중 제한을 갖는 경로이기 때문이죠. 간선의 가중치가 큰 순서대로 연결을 시도하기 때문이죠.

#include <bits/stdc++.h>

using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, M;
    cin >> N >> M;
    
    using Edge = tuple<int, int, int>;
    vector<Edge> edges(M);
    for(auto& [u, v, weight] : edges) {
        cin >> u >> v >> weight;
    }
    
    int src, dst;
    cin >> src >> dst;
    
    vector<int> p(N + 1);
    iota(p.begin(), p.end(), 0);
    
    sort(edges.begin(), edges.end(), [](const Edge& lhs, const Edge& rhs) {
        return get<2>(lhs) > get<2>(rhs);
    });
    
    auto Find = [&](int x) {
        while(x != p[x]) {
            p[x] = p[p[x]];
            x = p[x];
        }
        
        return p[x];
    };
    
    auto Union = [&](int u, int v) {
        u = Find(u);
        v = Find(v);
        
        p[u] = v;
    };
    
    for(const auto& [u, v, weight] : edges) {
        Union(u, v);
        if(Find(src) == Find(dst)) {
            cout << weight;
            break;
        }
    }
    
    return 0;
}

[g0rnn]

문제를 읽고 첨엔 그리디하게 가장 큰 노드를 찾으면서 가면 되겠다! 했는데 반례를 바로 찾아서 다른 방법을 고민했습니다. 그냥 브루트포스로 전부다 해야하나? 싶었는데 n이 10000인데 말이 안되죠..

10분을 더 고민하다가 우연찮게 이분 탐색이라는 생각이 떠올랐씁니다. 1 ~ 10000000까지 이분탐색으로 순회하면서 그 값을 가지는 경로가 존재하는지를 찾으면 된다 생각했어요. 근데 up & down 조건을 잘 맞추지 못해 답지를 봤습니다.

거의 다 왔는데 아쉽네요ㅜ 입력 관련해서 파이썬 문법을 몰라 준용님 코드를 보고 치다가 그냥 같아졌슴니다..

import sys
from collections import deque
input = sys.stdin.readline

def bfs(weight):
    visited = [False for _ in range(n+1)]
    q = deque()
    q.append(s)
    visited[s] = True
    while q:
        now = q.popleft()
        if now == e:
            return True
        
        for next, edge in graph[now]:
            if not visited[next] and edge >= weight:
                visited[next] = True
                q.append(next)
    return False

n, m = map(int, input().split())
graph = [[] for _ in range(n+1)]
for _ in range(m):
    a, b, w = map(int, input().split())
    graph[a].append((b, w))
    graph[b].append((a, w))
s, e = map(int, input().split())

left = 1
right = 1_000_000_000
answer = 0
while left <= right:
    mid = (left + right) // 2
    if bfs(mid):
        answer = mid
        left = mid + 1
    else:
        right = mid - 1
print(answer)