Torna alle sfide
Difficile 0 risolte 0% di accettazione

Course Schedule Order

Order courses so every prerequisite comes first.

Cosa imparerai

  • Order tasks by prerequisites with Kahn's algorithm
  • Track in-degrees with a queue
  • Detect impossible schedules

Problema

Mostra traduzione

Courses are numbered 0..n−1. Each pair [course, prerequisite] means the prerequisite must be taken before the course. Return an order to take all courses; when several courses are available, take the lowest-numbered one first so the answer is unique.

Implement course_order(n, prerequisites).

Input

n: The number of courses. prerequisites: Pairs [course, prerequisite].

Output

Return the course order, or an empty list if a cycle makes it impossible.

Vincoli

1 ≤ n ≤ 100,000; 0 ≤ pairs ≤ 200,000

Esempi

Esempio 1
Input:
n = 4
prerequisites = [
    [1, 0],
    [2, 0],
    [3, 1],
    [3, 2]
]

Output atteso:
expected = [0, 1, 2, 3]
Input:
long long n = 4;
std::vector<std::vector<long long>> prerequisites = {
    {1, 0},
    {2, 0},
    {3, 1},
    {3, 2}
};

Output atteso:
std::vector<long long> expected = {0, 1, 2, 3};
Input:
long n = 4;
long[][] prerequisites = new long[][] {
    new long[] {1, 0},
    new long[] {2, 0},
    new long[] {3, 1},
    new long[] {3, 2}
};

Output atteso:
long[] expected = new long[] {0, 1, 2, 3};

Spiegazione

0 first, then 1 and 2 (lowest first), then 3: [0, 1, 2, 3].

Esempio 2
Input:
n = 2
prerequisites = [
    [0, 1],
    [1, 0]
]

Output atteso:
expected = []
Input:
long long n = 2;
std::vector<std::vector<long long>> prerequisites = {
    {0, 1},
    {1, 0}
};

Output atteso:
std::vector<long long> expected = {};
Input:
long n = 2;
long[][] prerequisites = new long[][] {
    new long[] {0, 1},
    new long[] {1, 0}
};

Output atteso:
long[] expected = new long[] {};

Spiegazione

Each course requires the other, so no order exists: [].

Come affrontarlo

Prova prima da solo, poi apri un suggerimento alla volta.

Suggerimento 1

This is a dependency ordering problem: courses with no unmet prerequisites must be taken first.

Suggerimento 2

Use topological sorting, and when multiple courses are ready, always choose the smallest-numbered one to make the order deterministic.

Suggerimento 3

If you cannot process all courses, a cycle exists; also, duplicate prerequisite pairs should not break the result.

Complessità attesa

O(n + p log n) time, O(n + p) extra space

Riferimenti

Questa sfida è adattata per CodeUtility. Segui la traccia e i vincoli sopra.

Impara dagli altri

Soluzioni della community

Nessuna soluzione pubblicata. Risolvi questa sfida per condividere la prima.