Task Scheduler with Dependencies

Problem Context

You are building a simplified task execution engine that models both synchronous and asynchronous task pipelines. Each task has an ID, an execution duration, and a list of dependencies (tasks that must complete before it can start).

Your job is to simulate two execution modes:

• Synchronous mode (S): Tasks are executed one at a time in topological order. Each task starts only after the previous one finishes, regardless of dependencies being satisfied earlier.
• Asynchronous mode (A): Tasks are executed as soon as all their dependencies are complete (parallel execution is allowed). Tasks with no unmet dependencies can run simultaneously.

Given a list of tasks with durations and dependencies, and a mode, return the total time to complete all tasks.

Input Format

• n — number of tasks (0-indexed, IDs from 0 to n-1)
• durations — integer array where durations[i] is the time task i takes
• dependencies — list of [a, b] pairs meaning task b must finish before task a starts
• mode — string "S" for synchronous, "A" for asynchronous

Output Format

Return a single integer — the total completion time.

Examples

Example 1

Input: n=3, durations=[3,2,5], dependencies=[], mode="S" Output: 10 Explanation: Synchronous means tasks run one after another. Total = 3 + 2 + 5 = 10.

Example 2

Input: n=3, durations=[3,2,5], dependencies=[], mode="A" Output: 5 Explanation: With no dependencies, all tasks run in parallel. Total time = max(3, 2, 5) = 5.

Example 3

Input: n=3, durations=[3,2,5], dependencies=[[1,0],[2,1]], mode="A" Output: 10 Explanation: Task 0 starts at t=0, finishes at t=3. Task 1 can start at t=3, finishes at t=5. Task 2 can start at t=5, finishes at t=10. Even in async mode, the dependency chain forces sequential execution here.

Approach Hints

• Synchronous Mode: Perform a topological sort (BFS/DFS with in-degree tracking). Sum up all durations — order doesn't affect total in synchronous sequential execution.
• Asynchronous Mode: Use a modified BFS topological sort (Kahn's algorithm). Track the earliest start time for each task as . The answer is for all tasks.