Find Champion II - Practice Coding Problems

Find Champion II - Problem

Graph Medium

Find the Tournament Champion

Imagine a tournament with n teams numbered from 0 to n-1. The tournament results form a Directed Acyclic Graph (DAG) where each directed edge represents one team defeating another.

You're given:
• An integer n - the number of teams
• A 2D array edges where edges[i] = [ui, vi] means team ui defeated team vi

Goal: Find the tournament champion - the team that no other team has defeated. If there's exactly one such team, return its number. If there are multiple undefeated teams or no clear champion, return -1.

The champion is essentially the team with no incoming edges in the graph!

Input & Output

example_1.py — Basic Tournament

$ Input: n = 3, edges = [[0,1],[1,2]]

› Output: 0

💡 Note: Team 0 defeated team 1, and team 1 defeated team 2. Team 0 has never been defeated by anyone, making it the unique champion.

example_2.py — No Clear Champion

$ Input: n = 4, edges = [[0,2],[1,3],[1,2]]

› Output: -1

💡 Note: Teams 0 and 1 both have never been defeated. Since there are multiple undefeated teams, there's no unique champion.

example_3.py — Single Team

$ Input: n = 1, edges = []

› Output: 0

💡 Note: With only one team and no matches, team 0 is automatically the champion.

Visualization

Tap to expand

Understanding the Visualization

Build the Tournament Graph

Each directed edge shows which team defeated which other team

Count Defeats for Each Team

Track how many incoming edges (losses) each team has

Find the Champion

The champion has exactly zero losses (in-degree = 0)

Key Takeaway

🎯 Key Insight: The tournament champion is simply the team with in-degree 0 in the directed graph - no other team has defeated them!

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

O(m) to process all edges + O(n) to find champion among all teams

✓ Linear Growth

Space Complexity

O(n)

Array of size n to store in-degree count for each team

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
0 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 2
0 ≤ edge[i][j] ≤ n - 1
edge[i][0] ≠ edge[i][1]
The input is generated such that edges represent a valid DAG

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal solution uses in-degree counting to find the tournament champion in O(m + n) time. By counting how many times each team appears as a loser in the edges, we can identify the team with zero defeats. The champion is the unique team with in-degree 0 in the directed graph.

Common Approaches

Approach	Time	Space	Notes
✓ In-Degree Counting (Optimal)	O(m + n)	O(n)	Count incoming edges for each team in one pass, then find unique team with zero defeats
Brute Force (Check Every Team)	O(n*m)	O(1)	For each team, check all edges to see if anyone defeated them

In-Degree Counting (Optimal) — Algorithm Steps

Create an array to count defeats for each team
Scan through all edges once, incrementing defeat count for each losing team
Count how many teams have zero defeats
Return the undefeated team if exactly one exists, otherwise -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize defeat counter

Create array to count defeats for each team

Process all edges

For each edge, increment defeat count of losing team

Find champion

Look for team with exactly zero defeats

Code -

solution.c — C

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

int findChampion(int n, int** edges, int edgesSize, int* edgesColSize) {
    // Count defeats (in-degree) for each team
    int* defeats = (int*)calloc(n, sizeof(int));
    
    // Single pass through edges to count defeats
    for (int i = 0; i < edgesSize; i++) {
        defeats[edges[i][1]]++;
    }
    
    // Find teams with zero defeats
    int undefeatedCount = 0;
    int champion = -1;
    for (int team = 0; team < n; team++) {
        if (defeats[team] == 0) {
            undefeatedCount++;
            champion = team;
        }
    }
    
    free(defeats);
    // Return champion if exactly one undefeated team exists
    return undefeatedCount == 1 ? champion : -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

O(m) to process all edges + O(n) to find champion among all teams

✓ Linear Growth

Space Complexity

O(n)

Array of size n to store in-degree count for each team

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
0 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 2
0 ≤ edge[i][j] ≤ n - 1
edge[i][0] ≠ edge[i][1]
The input is generated such that edges represent a valid DAG

24.6K Views

Medium Frequency

~12 min Avg. Time

892 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

In-Degree Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler