{"id":33724,"date":"2024-11-01T09:19:40","date_gmt":"2024-11-01T09:19:40","guid":{"rendered":"http:\/\/atmokpo.com\/w\/?p=33724"},"modified":"2024-11-01T11:46:58","modified_gmt":"2024-11-01T11:46:58","slug":"python-coding-test-course-topological-sort","status":"publish","type":"post","link":"https:\/\/atmokpo.com\/w\/33724\/","title":{"rendered":"python coding test course, topological sort"},"content":{"rendered":"

<\/p>\n

\n Topological Sorting is a method of sorting nodes in a Directed Acyclic Graph (DAG). It arranges all edges in such a way that they point from the upper<\/em> node to the lower<\/em> node. This sorting is mainly used in determining the order of tasks, dependencies, and various programming problems.\n<\/p>\n

Problem Description<\/h2>\n

\n Given the number of classes N<\/code> and a list of edges<\/code> indicating the precedence relationships between classes, the problem is to determine the order in which the classes can be taken using the topological sorting algorithm.\n<\/p>\n

Input Format<\/h3>\n
\nN = 6\nedges = [(2, 1), (3, 1), (4, 1), (6, 4), (5, 2), (5, 3)]\n<\/pre>\n
Output Format<\/h3>\n
1 2 3 4 5 6<\/code> (One possible order in which the classes can be taken)<\/p>\n
Problem Solving Process<\/h2>\n
1. Understanding the Problem<\/h3>\n
\n    The topological sorting problem is to establish the precedence relationships through the given nodes (N) and edge information (edges), and then sort all the nodes. Here, edges<\/code> is represented in the form of (A, B), indicating that A must be taken before B can be taken.\n<\/p>\n
2. Handling Input Parameters<\/h3>\n
\n    To implement topological sorting, we first need to construct the graph’s adjacency list and the in-degree array. The in-degree array counts the number of classes each node must attend.\n<\/p>\n
from collections import deque\n\ndef topological_sort(N, edges):\n    # Initialize graph and in-degree\n    graph = [[] for _ in range(N + 1)]\n    in_degree = [0] * (N + 1)\n    \n    # Register edge information in the graph and in-degree\n    for u, v in edges:\n        graph[u].append(v)\n        in_degree[v] += 1\n<\/code><\/pre>\n
3. Designing the Topological Sorting Algorithm<\/h3>\n
\n    Now, let’s design the algorithm to perform topological sorting. We will add nodes with an in-degree of 0 to a queue, and as we remove nodes one by one from the queue, we will decrease the in-degrees of the nodes connected to that node. Nodes whose in-degree becomes 0 after the decrease will be added back to the queue. This process will be repeated until the queue is empty. Ultimately, we will return the sorted order of nodes.\n<\/p>\n
    # Add nodes with in-degree of 0 to the queue\n    queue = deque()\n    for i in range(1, N + 1):\n        if in_degree[i] == 0:\n            queue.append(i)\n\n    result = []\n    \n    while queue:\n        current = queue.popleft()\n        result.append(current)\n        \n        for neighbor in graph[current]:\n            in_degree[neighbor] -= 1\n            if in_degree[neighbor] == 0:\n                queue.append(neighbor)\n\n    return result\n<\/code><\/pre>\n
4. Writing and Executing the Complete Code<\/h3>\n
\n    Now let’s integrate the entire code to write the final code. We can pass the processed input values to the function to check the results.\n<\/p>\n
N = 6\nedges = [(2, 1), (3, 1), (4, 1), (6, 4), (5, 2), (5, 3)]\n\nsorted_order = topological_sort(N, edges)\nprint(\"Order of classes that can be taken:\", sorted_order)\n<\/code><\/pre>\n
5. Results and Evaluation<\/h3>\n
\n    Running the above code will allow us to find an order of classes that can be taken through topological sorting. Due to the nature of the graph, multiple correct answers may arise. Therefore, if the algorithm is functioning correctly, it is necessary to broadly validate the validity of the results.\n<\/p>\n
6. Code and Algorithm Optimization<\/h3>\n
\n    The time complexity of the topological sorting algorithm is O(V + E), where V is the number of vertices and E is the number of edges. This algorithm can operate efficiently even with large datasets, making it a useful tool for employment coding tests.\n<\/p>\n
Conclusion<\/h2>\n
\n    Topological sorting is a useful algorithm in graph theory, applicable to various problems. In this lecture, we implemented topological sorting using Python and provided content suitable for practical coding tests. We hope you will continue to understand and utilize such algorithmic problems in depth.\n<\/p>\n
References<\/h2>\n