如何提高课程安排问题中循环检测的 Python 实现的运行时间？

Question

My aim is to improve the speed of my Python code that has been successfully accepted in a leetcode problem, Course Schedule .

I am aware of the algorithm but even though I am using O(1) data-structures, my runtime is still poor: around 200ms.

My code uses dictionaries and sets:

from collections import defaultdict


class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        course_list = []
        pre_req_mapping = defaultdict(list)
        visited = set()
        stack = set()
        def dfs(course):
            if course in stack:
                return False
            stack.add(course)
            visited.add(course)
            for neighbor in pre_req_mapping.get(course, []):
                if neighbor in visited:
                    no_cycle = dfs(neighbor)
                    if not no_cycle:
                        return False
            stack.remove(course)
            return True
        # for course in range(numCourses):
        #     course_list.append(course)
        for pair in prerequisites:
            pre_req_mapping[pair[1]].append(pair[0])
        for course in range(numCourses):
            if course in visited:
                continue
            no_cycle = dfs(course)
            if not no_cycle:
                return False
        return True

What else can I do to improve the speed?

Answer 1

You are calling dfs() for a given course multiple times. But its return value won't change. So we have an opportunity to memoize it. Change your algorithmic approach (here, to dynamic programming) for the big win. It's a space vs time tradeoff. EDIT: Hmmm, you are already memoizing most of the computation with visited , so lru_cache would mostly improve clarity rather than runtime. It's just a familiar idiom for caching a result.

It would be helpful to add a # comment citing a reference for the algorithm you implemented.

This is a very nice expression, with defaulting: pre_req_mapping.get(course, []) If you use timeit you may find that the generated bytecode for an empty tuple () is a tiny bit more efficient than that for an empty list [] , as it involves fewer allocations. Ok, some style nits follow, unrelated to runtime.

As an aside, youAreMixingCamelCase and_snake_case. PEP-8 asks you to please stick with just snake_case.

This is a fine choice of identifier name:

    for pair in prerequisites:

But instead of the cryptic [0] , [1] dereferences, it would be easier to read a tuple unpack:

    for course, prereq in prerequisites:

if not no_cycle: is clumsy. Consider inverting the meaning of dfs' return value, or rephrasing the assignment as:

        cycle = not dfs(course)

Answer 2

I think that you are doing it in good way, but since Python is an interpreted language, it's normal to have slow runtime compared with compiled languages like C/C++ and Java, especially for large inputs.

Try to write the same code in C/C++ for example and compare the speed between them.