## Question

Suppose you are at a party with `n`

people labeled from `0`

to `n - 1`

and among them, there may exist one celebrity. The definition of a celebrity is that all the other `n - 1`

people know the celebrity, but the celebrity does not know any of them.

Now you want to find out who the celebrity is or verify that there is not one. You are only allowed to ask questions like: "Hi, A. Do you know B?" to get information about whether A knows B. You need to find out the celebrity (or verify there is not one) by asking as few questions as possible (in the asymptotic sense).

You are given a helper function `bool knows(a, b)`

that tells you whether `a`

knows `b`

. Implement a function `int findCelebrity(n)`

. There will be exactly one celebrity if they are at the party.

Return *the celebrity's label if there is a celebrity at the party*. If there is no celebrity, return `-1`

.

**Example 1:**

```
Input: graph = [[1,1,0],[0,1,0],[1,1,1]]
Output: 1
Explanation: There are three persons labeled with 0, 1 and 2. graph[i][j] = 1 means person i knows person j, otherwise graph[i][j] = 0 means person i does not know person j. The celebrity is the person labeled as 1 because both 0 and 2 know him but 1 does not know anybody.
```

**Example 2:**

```
Input: graph = [[1,0,1],[1,1,0],[0,1,1]]
Output: -1
Explanation: There is no celebrity.
```

**Constraints:**

`n == graph.length == graph[i].length`

`2 <= n <= 100`

`graph[i][j]`

is`0`

or`1`

.`graph[i][i] == 1`

## Algorithm

There is a trivial solution , which is brute force. You loop all the people and then for each guy you loop all the other to check if everyone else knows him but he knows no one. This solution has a O(n*n) time complexity.

Actually we have a quicker solution. If you can come up the O(n*n) solution, then you could check this. So we loop all the first, find the last one whom everyone else knows; then we loop again of these people with this celebrity, to check if he satisfied the famous person's requirement: everyone knows him, he know no one else. If so, we return this guy, otherwise we have no famous person and return -1.

## Code

/* The knows API is defined in the parent class Relation. boolean knows(int a, int b); */ public class Solution extends Relation { public int findCelebrity(int n) { int res = -1; for (int i = 0; i < n; i++) { boolean found = true; for (int j = 0; j < n; j++) { if (i != j) { if (!knows(j, i) || knows(i, j)) { found = false; break; } } } if (found) return i; } return res; } }

public class Solution extends Relation { public int findCelebrity(int n) { int res = 0; for (int i = 1; i < n; i++) { if (knows(res, i)) res = i; } for (int i = 0; i < n; i++) { if (res != i && (knows(res, i) || !knows(i, res)) ) return -1; } return res; } }