6-Me-in-U

[Me-in-U]

🔗 문제 링크

2252번 줄 세우기

✔️ 소요된 시간

1시간

✨ 수도 코드

위상 정렬(topological sorting)은 유향 그래프의 꼭짓점들(vertex)을 변의 방향을 거스르지 않도록 나열하는 것을 의미한다.

예시) 만약 특정 수강과목에 선수과목이 있다면 그 선수 과목부터 수강해야 하므로, 특정 과목들을 수강해야 할 때 위상 정렬을 통해 올바른 수강 순서를 찾아낼 수 있다.

1.

Input: G = (V, E)

1. inDegree가 0인 vertex를 큐에 추가한다.
2. 큐가 비어있지 않으면 아래 반복
3. 큐에서 정점 x를 꺼낸다
4. 정점 x와 연결된 정점의 차수를 1 내린다.
5. 줄어든 차수가 1일 경우 해당 정점을 큐에 추가한다.

public static String topologySort(int N) {
    StringBuilder sb = new StringBuilder();
    Queue<Integer> queue = new LinkedList<>();
    for (int i = 1; i < N + 1; i++) {
        if (inDegree[i] == 0) {
            queue.add(i);
        }
    }
    while (!queue.isEmpty()) {
        int now = queue.poll();
        sb.append(now).append(' ');
        for (int next : graph[now]) {
            if (--inDegree[next] == 0) {
                queue.add(next);
            }
        }
    }
    return sb.toString();
}

초기 상태

그래프 G
1 -> 3
2 -> 3
3 ->

inDegree[]
{0,0,2}

큐에 차수가 0인 정점 추가

1. 반복 Queue(1,2)
   {
   큐에서 1을 꺼내고 "1" 출력
   1과 연결된 정점 3의 차수를 1감소 => inDegree[]{0,0,1}
   }

2. 반복 Queue(2)
   {
   큐에서 2을 꺼내고 "2" 출력
   2와 연결된 정점 3의 차수를 1감소 => inDegree[]{0,0,0}
   줄어든 차수가 0이 되었음으로 큐에 0추가
   }

3. 반복 Queue(3)
   {
   큐에서 3을 꺼내고 "3" 출력
   }

종료.

출력 결과 1,2,3

큐에 넣는 순서에 따라서 2,1,3이 될 수도 있다.
물론 이것도 정답이다.

[9kyo-hwang]

위상 정렬은 DFS를 이용해서도 수행할 수 있죠. 별도로 진입차수를 기록할 필요 없이, 기본적인 DFS 수행하듯 하되 함수 마지막에 방문한 노드를 넣는 식의 변형만 주면 되기 때문에 코드가 BFS 방식에 비해 심플하다고 생각되네요 :)

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

public class Main {
    static int N, M;
    static List<Integer>[] adjacencyList;
    static List<Integer> orderOfVisit;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        
        adjacencyList = new ArrayList[N + 1];
        for (int i = 0; i <= N; i++) {
            adjacencyList[i] = new ArrayList<>();
        }
        
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int A = Integer.parseInt(st.nextToken());
            int B = Integer.parseInt(st.nextToken());
            adjacencyList[A].add(B);
        }
        
        topologySort();
        
        Collections.reverse(orderOfVisit);
        for (int node : orderOfVisit) {
            bw.write(node + " ");
        }
        bw.flush();
        bw.close();
        br.close();
    }

    static void DFS(boolean[] visited, int srcNode) {
        visited[srcNode] = true;
        for (int dstNode : adjacencyList[srcNode]) {
            if (!visited[dstNode]) {
                DFS(visited, dstNode);
            }
        }
        orderOfVisit.add(srcNode);
    }

    static void topologySort() {
        boolean[] visited = new boolean[N + 1];
        orderOfVisit = new ArrayList<>();
        for (int node = 1; node <= N; node++) {
            if (!visited[node]) {
                DFS(visited, node);
            }
        }
    }
}

[wjdheesp44]

import sys
from collections import deque

input = sys.stdin.readline
N, M = map(int, input().split())

in_degree = [0]*(N+1)
graph = [[] for _ in range(N+1)]
q = deque()
answer = []

for i in range(M):
    a, b = map(int, input().split())
    graph[a].append(b)
    in_degree[b] += 1

for i in range(1, N+1):
    if in_degree[i] == 0:
        q.append(i)

while q:
    tmp = q.popleft()
    answer.append(tmp)
    for i in graph[tmp]:
        in_degree[i] -= 1
        if in_degree[i] == 0:
            q.append(i)

for i in answer:
    print(i, end=' ')

위상정렬에 대해 처음 알게 되었네요. 저는 bfs로 풀어봤습니다. 고생하셨습니다!

[erase-jeong]

이번기회에 위상정렬에 대해서 알게되고 공부해보게 되었네요!

수고하셨습니다~

from collections import deque


def sort(N,comparisons):
    graph=[[] for _ in range(N+1)] 
    in_degree=[0]*(N+1)  

    for A,B in comparisons:
        graph[A].append(B)
        in_degree[B]+=1


    queue=deque()
    for i in range(1,N+1):
        if in_degree[i]==0:
            queue.append(i)

    
    result=[]
    while queue:
        current=queue.popleft()
        result.append(current)
        for neighbor in graph[current]:
            in_degree[neighbor]-=1
            if in_degree[neighbor]==0:
                queue.append(neighbor)


    return result

    
N,M=map(int,input().split())

comparisons=[] 
for _ in range(M): 
    a,b=map(int,input().split()) 
    comparisons.append((a,b)) 


sorted_students=sort(N,comparisons)

print(' '.join(map(str,sorted_students)))