Task Dependency Resolver - Problem

Given a list of tasks and their dependencies, find a valid execution order that respects all dependencies. If there are circular dependencies, return "CYCLE".

Each task is represented by an integer, and dependencies are given as pairs [a, b] meaning task b depends on task a (so a must be completed before b).

Requirements:

Return any valid topological ordering of tasks
If a cycle exists, return the string "CYCLE"
Tasks are numbered from 0 to n-1

Input & Output

Example 1 — Basic Dependency Chain

$ Input: numTasks = 3, dependencies = [[0,1],[1,2]]

› Output: [0,1,2]

💡 Note: Task 1 depends on task 0, and task 2 depends on task 1. So the valid order is 0 → 1 → 2.

Example 2 — No Dependencies

$ Input: numTasks = 2, dependencies = []

› Output: [0,1]

💡 Note: No dependencies between tasks, so any order is valid. [0,1] or [1,0] both work.

Example 3 — Circular Dependency

$ Input: numTasks = 2, dependencies = [[0,1],[1,0]]

› Output: CYCLE

💡 Note: Task 0 depends on task 1, and task 1 depends on task 0. This creates a circular dependency.

Constraints

0 ≤ numTasks ≤ 10⁴
0 ≤ dependencies.length ≤ 5000
dependencies[i].length == 2
0 ≤ a_i, b_i < numTasks
a_i ≠ b_i

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to use topological sorting to find a valid task execution order. The best approach is Kahn's algorithm using BFS with in-degree counting. Time: O(V+E), Space: O(V+E).

Common Approaches

✓ DFS with Cycle Detection

⏱️ Time: O(V + E) Space: O(V + E)

Perform DFS from each unvisited node, tracking visited states to detect cycles. Build the result in reverse post-order.

Kahn's Algorithm (BFS)

⏱️ Time: O(V + E) Space: O(V + E)

Count incoming edges (in-degrees) for each node. Process nodes with zero in-degree, removing their outgoing edges and updating neighbors' in-degrees.

Try All Permutations

⏱️ Time: O(n! × m) Space: O(n)

Generate every possible permutation of tasks and check if each ordering satisfies all dependencies. This requires factorial time complexity.

DFS with Cycle Detection — Algorithm Steps

Build adjacency list from dependencies
For each unvisited node, start DFS
Use three states: unvisited, visiting, visited
If we reach a 'visiting' node, there's a cycle
Add nodes to result in reverse post-order

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin from unvisited nodes, mark as visiting

Check Neighbors

Recursively visit dependencies

Post-order Result

Add to result when fully processed

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int graph[100][100];
int graphSize[100];
int state[100];
int result[100];
int resultSize = 0;

int dfs(int node, int numTasks) {
    if (state[node] == 1) return 0;
    if (state[node] == 2) return 1;
    
    state[node] = 1;
    
    for (int i = 0; i < graphSize[node]; i++) {
        if (!dfs(graph[node][i], numTasks)) {
            return 0;
        }
    }
    
    state[node] = 2;
    result[resultSize++] = node;
    return 1;
}

void reverse(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

int main() {
    int numTasks;
    scanf("%d", &numTasks);
    
    if (numTasks == 0) {
        printf("[]\n");
        return 0;
    }
    
    for (int i = 0; i < numTasks; i++) {
        graphSize[i] = 0;
        state[i] = 0;
    }
    resultSize = 0;
    
    char line[1000];
    scanf(" %s", line);
    
    if (strcmp(line, "[]") != 0) {
        char* ptr = line + 1;
        while (*ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                int a = atoi(ptr);
                while (*ptr != ',') ptr++;
                ptr++;
                int b = atoi(ptr);
                graph[a][graphSize[a]++] = b;
                while (*ptr != ']') ptr++;
                ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    for (int i = 0; i < numTasks; i++) {
        if (state[i] == 0) {
            if (!dfs(i, numTasks)) {
                printf("CYCLE\n");
                return 0;
            }
        }
    }
    
    reverse(result, resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and each edge once during DFS traversal

⚠ Quadratic Growth

Space Complexity

O(V + E)

Adjacency list storage plus recursion stack depth up to V

⚡ Linearithmic Space

125.0K Views

High Frequency

~25 min Avg. Time

3.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Task Dependency Resolver - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS with Cycle Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler