Find Champion II

Problem

There are n teams numbered from 0 to n - 1 in a tournament; each team is also a node in a DAG.

You are given the integer n and a 0-indexed 2D integer array edges of length m representing the DAG , where edges[i] = [ui, vi] indicates that there is a directed edge from team ui to team vi in the graph.

A directed edge from a to b in the graph means that team a is stronger than team b and team b is weaker than team a.

Team a will be the champion of the tournament if there is no team b that is stronger than team a.

Return _the team that will be thechampion of the tournament if there is a unique champion, otherwise, return _-1 .

Notes

A cycle is a series of nodes a1, a2, ..., an, an+1 such that node a1 is the same node as node an+1, the nodes a1, a2, ..., an are distinct, and there is a directed edge from the node ai to node ai+1 for every i in the range [1, n].
A DAG is a directed graph that does not have any cycle.

Examples

Example 1:

graph TB;
	0 --> 1 
	1 --> 2

1
2
3


Input: n = 3, edges = [[0,1],[1,2]]
Output: 0
Explanation: Team 1 is weaker than team 0. Team 2 is weaker than team 1. So the champion is team 0.

Example 2:

graph TB;
	0 --> 2
	1 --> 2
	1 --> 3

1
2
3


Input: n = 4, edges = [[0,2],[1,3],[1,2]]
Output: -1
Explanation: Team 2 is weaker than team 0 and team 1. Team 3 is weaker than team 1. But team 1 and team 0 are not weaker than any other teams. So the answer is -1.

Constraints:

1 <= n <= 100
m == edges.length
0 <= m <= n * (n - 1) / 2
edges[i].length == 2
0 <= edge[i][j] <= n - 1
edges[i][0] != edges[i][1]
The input is generated such that if team a is stronger than team b, team b is not stronger than team a.
The input is generated such that if team a is stronger than team b and team b is stronger than team c, then team a is stronger than team c.

Solution

Method 1 - Using indegrees

Here is the approach:

Understanding the Problem:
- Each team is a node in a Directed Acyclic Graph (DAG).
- A directed edge from node a to node b indicates team a is stronger than team b.
Goal:
- Determine if there is a unique champion i.e., a node with no incoming edges except itself.
Plan:
- Initialize an array to track the in-degree of each node.
- Traverse the graph and compute the in-degree for each node.
- Check for nodes with zero in-degree. There should be exactly one such node for a unique champion.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


class Solution {
    public int findChampion(int n, int[][] edges) {
        int[] inDegree = new int[n];
        
        // Calculate in-degrees
        for (int[] edge : edges) {
            inDegree[edge[1]]++;
        }
        
        int champion = -1;
        
        // Look for the node with in-degree 0
        for (int i = 0; i < n; i++) {
            if (inDegree[i] == 0) {
                if (champion == -1) {
                    champion = i;
                } else {
                    // More than one node with in-degree 0
                    return -1;
                }
            }
        }
        
        return champion;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Solution:
    def findChampion(self, n: int, edges: List[List[int]]) -> int:
        in_degree: List[int] = [0] * n
        
        # Calculate in-degrees
        for edge in edges:
            in_degree[edge[1]] += 1
        
        champion: int = -1
        
        # Look for the node with in-degree 0
        for i in range(n):
            if in_degree[i] == 0:
                if champion == -1:
                    champion = i
                else:
                    # More than one node with in-degree 0
                    return -1
                
        return champion

Complexity

⏰ Time complexity: O(n + m)
- O(n) for initializing the array.
- O(m) for traversing the edges.
🧺 Space complexity: O(n) for the in-degree array.

Problem#

Examples#

Solution#

Method 1 - Using indegrees#

Code#

Complexity#