Find the Town Judge

Find the Town Judge - Problem

In a town, there are n people labeled from 1 to n. There is a rumor that one of these people is secretly the town judge.

If the town judge exists, then:

The town judge trusts nobody.
Everybody (except for the town judge) trusts the town judge.
There is exactly one person that satisfies properties 1 and 2.

You are given an array trust where trust[i] = [a_i, b_i] representing that the person labeled a_i trusts the person labeled b_i.

Return the label of the town judge if the town judge exists and can be identified, or return -1 otherwise.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, trust = [[1,2],[3,2]]

› Output: 2

💡 Note: Person 1 trusts person 2, person 3 trusts person 2, and person 2 trusts nobody. Person 2 is trusted by 2 people (everyone except themselves) and trusts nobody, so they are the judge.

Example 2 — No Judge

$ Input: n = 3, trust = [[1,3],[2,3],[3,1]]

› Output: -1

💡 Note: No one satisfies the judge criteria. Person 3 is trusted by persons 1 and 2, but person 3 also trusts person 1, so they cannot be the judge.

Example 3 — Single Person

$ Input: n = 1, trust = []

› Output: 1

💡 Note: With only one person in the town, they must be the judge by default since there are no trust relationships.

Constraints

1 ≤ n ≤ 1000
0 ≤ trust.length ≤ 10⁴
trust[i].length == 2
All the pairs of trust are unique
a_i ≠ b_i
1 ≤ a_i, b_i ≤ n

Visualization

Tap to expand

Asked in

A Amazon 15 G Google 8

The key insight is that the judge has a unique trust pattern: trusted by everyone else but trusts nobody. We can solve this efficiently using a trust score system where each person gets +1 for being trusted and -1 for trusting others. The judge will have a score of exactly n-1. Best approach uses single array trust scoring with Time: O(n + m), Space: O(n).

Common Approaches

✓ Brute Force Check

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

For each person, scan through all trust relationships to count how many people trust them and how many people they trust. A judge must be trusted by exactly n-1 people and trust nobody.

Single Array Trust Score

⏱️ Time: O(n + m) Space: O(n)

Instead of separate arrays, use a single trust score where each person gets +1 when trusted by someone and -1 when they trust someone. The judge will have a score of exactly n-1.

Trust Score Counting

⏱️ Time: O(n + m) Space: O(n)

Use two arrays to separately count how many people each person trusts (outgoing) and how many people trust them (incoming). The judge has incoming count of n-1 and outgoing count of 0.

Brute Force Check — Algorithm Steps

Step 1: For each person 1 to n, count incoming trust (how many trust them)
Step 2: For each person 1 to n, count outgoing trust (how many they trust)
Step 3: Find person with incoming trust = n-1 and outgoing trust = 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Person 1

Count trust relationships involving person 1

Check Person 2

Count trust relationships involving person 2

Found Judge

Person with n-1 incoming, 0 outgoing trust

Code -

solution.c — C

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

int solution(int n, int trust[][2], int trustSize) {
    for (int candidate = 1; candidate <= n; candidate++) {
        int trustedBy = 0;
        int trustsOthers = 0;
        
        for (int i = 0; i < trustSize; i++) {
            if (trust[i][1] == candidate) trustedBy++;
            if (trust[i][0] == candidate) trustsOthers++;
        }
        
        if (trustedBy == n - 1 && trustsOthers == 0) {
            return candidate;
        }
    }
    
    return -1;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    int trust[1000][2];
    int trustSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* ptr = line + 1;
        while (*ptr && *ptr != ']') {
            if (*ptr == '[') {
                ptr++;
                trust[trustSize][0] = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                ptr++;
                trust[trustSize][1] = atoi(ptr);
                trustSize++;
                while (*ptr && *ptr != ']') ptr++;
                ptr++;
                if (*ptr == ',') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    printf("%d\n", solution(n, trust, trustSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of n people, scan m trust relationships

✓ Linear Growth

Space Complexity

O(1)

Only using counter variables

⚡ Linearithmic Space

156.0K Views

Medium Frequency

~15 min Avg. Time

3.2K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler