50-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

26146 즉흥 여행 (Easy)

✔️ 소요된 시간

30분

✨ 수도 코드

1. 문제

N개의 노드와 M개의 엣지로 이루어진 방향 그래프가 존재한다.
어떤 노드에서 출발하든지, 다른 모든 노드로 갈 수 있는지 검사하라.

조건

• $1 \le N \le 200,000$
• $1 \le M \le 500,000$

예시 1

4 5  // N = 4, M = 5
1 2  // M개의 줄에 걸쳐 엣지 정보가 주어짐
2 3  // 출발 노드, 도착 노드
3 1
1 4
4 1

무슨 시작점을 선택하든 모든 정점을 방문할 수 있는 경로를 찾을 수 있으므로, 답은 Yes가 된다. 아래는 가능한 경로 중 하나이다.

• 1 → 4 → 1 → 2 → 3
• 2 → 3 → 1 → 4
• 3 → 1 → 2 → 3 → 1 → 4
• 4 → 1 → 4 → 1 → 2 → 3 → 1

예시 2

4 4
1 2
2 3
3 4
4 2

1번 정점에서 출발하면 모든 정점을 방문할 수 있는 경로가 존재하지만, 2번 정점에서 출발하면 모든 정점을 방문할 수 있는 경로가 존재하지 않으므로, 답은 No가 된다.

2. 풀이

옆 동네에서 "강연결 그래프"에 관한 PR을 작성했는데, 이를 보고 예전에 알고리즘 기말고사 시험에 나왔던 내용이 떠올랐다.

• 22년 1학기 권 교수님 알고리즘 기말고사 문제 :)

위 이미지에서 적힌 설명대로, 강연결 그래프인지 확인하는 방법은 아래와 같다.

1. 주어진 그래프 $G$에 대해, 임의의 정점 u에서 출발하는 BFS/DFS를 수행해 다른 모든 정점에 도달할 수 있는 지 검사
2. 주어진 그래프 $G$에서 모든 엣지들의 방향을 뒤집은 $G^C$를 만든 뒤 동일한 임의의 정점 u에서 출발하는 BFS/DFS를 수행해 다른 모든 정점에 도달할 수 있는 지 검사
3. 1, 2번이 모두 가능하다면 강연결 그래프

이를 토대로 코드를 작성한다.

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N, M; cin >> N >> M;  
    
    vector<vector<int>> G(N + 1);
    vector<vector<int>> GC(N + 1);
    
    while(M--)
    {
        int v, w; cin >> v >> w;
        G[v].emplace_back(w);
        GC[w].emplace_back(v);
    }
    
    cout << (DFS(N, G) && DFS(N, GC) ? "Yes" : "No");

    return 0;
}

입력으로 엣지들이 주어질 때, 정방향 그래프 $G$와 역방향 그래프 $G^C$를 구축한다.
DFS 함수를 두 그래프에 대해 호출해 모두 True가 반환됐다면 "Yes"를 출력하고, 하나라도 False가 반환됐다면 "No"를 출력한다.

bool DFS(const int N, vector<vector<int>>& Graph)
{
    vector<bool> Visited(N + 1, false);
    DFSHelper(Graph, Visited);
    
    for(int Node = 1; Node <= N; ++Node)
    {
        if(!Visited[Node])
        {
            return false;
        }
    }
    return true;
}

DFS 함수는 방문 체크를 확인하는 Visited 리스트를 생성한뒤, 실질적으로 DFS를 수행하는 DFSHelper 함수를 호출하는 역할을 담당한다.
DFSHelper 함수를 수행한 뒤 Visited 리스트를 순회해 하나라도 도달하지 못한 노드가 존재하는 return false, 아니라면 return true를 반환한다.

void DFSHelper(const vector<vector<int>>& Graph, vector<bool>& Visited, int SrcNode = 1)
{
    Visited[SrcNode] = true;
    for(const auto& DstNode : Graph[SrcNode])
    {
        if(!Visited[DstNode])
        {
            DFSHelper(Graph, Visited, DstNode);
        }
    }
}

DFSHelper 함수는 전형적인 DFS 순회 함수이다. "임의의 노드"에 대해 출발하면 되므로 최초 출발 노드를 1번으로 지정한다.

이 알고리즘은 2번의 DFS만 수행하면 되므로 시간 복잡도는 $O(2 * (N + M)) = O(N + M)$이다.

전체 코드

#include <iostream>
#include <vector>

using namespace std;

void DFSHelper(const vector<vector<int>>& Graph, vector<bool>& Visited, int SrcNode = 1)
{
    Visited[SrcNode] = true;
    for(const auto& DstNode : Graph[SrcNode])
    {
        if(!Visited[DstNode])
        {
            DFSHelper(Graph, Visited, DstNode);
        }
    }
}

bool DFS(const int N, vector<vector<int>>& Graph)
{
    vector<bool> Visited(N + 1, false);
    DFSHelper(Graph, Visited);
    
    for(int Node = 1; Node <= N; ++Node)
    {
        if(!Visited[Node])
        {
            return false;
        }
    }
    return true;
}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N, M; cin >> N >> M;
    
    vector<vector<int>> G(N + 1);
    vector<vector<int>> GC(N + 1);
    
    while(M--)
    {
        int v, w; cin >> v >> w;
        G[v].emplace_back(w);
        GC[w].emplace_back(v);
    }
    
    cout << (DFS(N, G) && DFS(N, GC) ? "Yes" : "No");

    return 0;
}

📚 새롭게 알게된 내용

사실 이 내용은 SCC(Strongly Connected Component, 강한 연결 요소) 에 대한 특수 케이스이다.
일반적으로 그래프 내 여러 개의 SCC를 추출하는 형식인데, 이 문제는 전체 그래프에 대해 SCC가 하나만 존재하는 경우이다.

SCC를 추출하는 대표적인 알고리즘 2가지가 "코사라주 알고리즘"과 "타잔 알고리즘"인데, 여기서 사용된 알고리즘이 "코사라주 알고리즘"과 거의 동일하다.

만약 이 알고리즘을 사용하지 않는다면 "모든 노드에 대해" 한 번씩 BFS/DFS를 수행해야 하는데, 이는 $O(N * (N + M))$ 시간복잡도가 걸려 최악의 경우 1400억번의 연산이 필요해 시간이 초과한다.

[mjj111]

N과 M이 너무 크다보니 ,O(NM) O(N**2)... 이상으로는 해결할 수 없어보였습니다..
그래서 N +M 으로 순회를 한 번 하고서 흔적을 남겨,
각 노드가 어디까지 접근이 가능한지를 기록해주면 어떨까란 아이디어를 떠올렸어요.

그런데.. 루프가 있을 경우에 대해서 위 과정은 불가하더군요 😢(20분 헛짓)
결국에 교황님께서 참고해주신 강연결그래프 관련 내용 읽고 겨우 풀었네요 ㅠ

너무 좋은 문제..! 고생하셨습니다👍

public class Main {

    static boolean[] visited;
    static Stack<Integer> stack = new Stack<>();

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

        int v = Integer.parseInt(st.nextToken());
        int e = Integer.parseInt(st.nextToken());

        visited = new boolean[v + 1];
        List<Integer>[] graph = new ArrayList[v + 1];
        List<Integer>[] reverseGraph = new ArrayList[v + 1];

        for(int i = 1; i <= v; i++) {
            graph[i] = new ArrayList<>();
            reverseGraph[i] = new ArrayList<>();
        }

        for(int i = 0; i < e; i++) {
            st = new StringTokenizer(br.readLine());
            int from = Integer.parseInt(st.nextToken());
            int to = Integer.parseInt(st.nextToken());

            graph[from].add(to);
            reverseGraph[to].add(from);
        }

        for(int i = 1; i <= v; i++) {
            if(!visited[i]) {
                dfs(i, graph, false);
            }	//방문 하지 않았다면 dfs로 방문
        }

        visited = new boolean[v + 1];
        dfs(stack.pop(), reverseGraph, true);

        String answer = "Yes";
        while(!stack.isEmpty()) {
            // 스택이 비어있을때까지 꺼내는데, 방문하지 않았다면 모두 연결되어 있지 않으므로 No
            if(!visited[stack.pop()]) {
                answer = "No";
                break;
            }
        }

        System.out.print(answer);
    }

    public static void dfs(int depth, List<Integer>[] graph, boolean isReverseGraph) {
        visited[depth] = true;

        for(int a : graph[depth]) {
            if(!visited[a]) {
                dfs(a, graph, isReverseGraph);
            }
        }

        // 정방향 그래프일 경우에만 stack에 저장
        if(!isReverseGraph) {
            stack.add(depth);
        }
    }
}

[xxubin04]

SCC..! 엄청 자세하게 써주신 설명 덕분에 쉽게 이해하고 갑니다!
앞으로 시작점이 주어지지 않고 어떻게든 모든 노드를 방문할 수 있는지를 묻는 문제가 나오면, 강연결 그래프를 떠올리면 되겠군요!

문제를 도전해보았는데 시간초과가 엄청나게 났습니다..
그래서 코사라주 알고리즘으로 다시 풀어보려다 시간이 오래 걸릴 것 같아 우선 리뷰 급하게 남깁니다!!
시간초과났지만 우선 올리도록 하겠습니다🤯

시간초과 난 코드...

from collections import deque
import sys
sys.setrecursionlimit(10**6)
input = open(0).readline

nation_num, flight_num = map(int, input().split())
forward_graph = [[] for _ in range(nation_num + 1)]
reverse_graph = [[] for _ in range(nation_num + 1)]

for i in range(flight_num):
    n, m = map(int, input().split())
    forward_graph[n].append(m)
    reverse_graph[m].append(n)

def DFS(q, visited, graph):
    while q:
        x = q.popleft()

        if not visited[x]:
            visited[x] = 1
            for node in graph[x]:
                q.append(node)
            DFS(q, visited, graph)

for k in range(1, nation_num+1):
    q_f, q_r = deque([k]), deque([k])
    visited_f = [1] + [0 for _ in range(nation_num)]
    visited_r = [1] + [0 for _ in range(nation_num)]
    DFS(q_f, visited_f, forward_graph)
    DFS(q_r, visited_r, reverse_graph)

    if sum(visited_f) == nation_num+1 and sum(visited_r) == nation_num+1:
        print("Yes")
        break

    elif k == nation_num and(sum(visited_f) != nation_num or sum(visited_r) != nation_num):
        print("No")

[gjsk132]

나름 쌈빡한 풀이를 생각은 했지만... 구현 단계에서 포기했습니다.

1. 1번 지점에서 시작해서, 모든 경로에 대해 다시 1번 지점으로 돌아올 수 있다.
2. 위 과정에서 모든 노드를 지났다.

위에 2가지가 된다면, Yes를 출력한다! 라고 하고 싶었지만...
코드 짜기에 실패하고, 어찌저찌 일단 제출했는데, 시간 초과라는 결과가...ㅜㅠ
이게 왜 시간 초과 나지

SCC라니... 요즘 하면 할수록 아직 못 들어본 알고리즘도 엄청 많이 남았다는걸 깨닫습니다...

ㅎ...한 시간만 더 이 문제에 투자해볼게요