def destCity(self, paths: List[List[str]]) -> str:
        
        # Note:
        # Finding the destination city
        # using a Directed Edge List

        # Directed Edge List:
        # paths = [
        #     ["London", "New York"],
        #     ["New York", "Lima"],
        #     ["Lima", "Sao Paulo"],
        # ]

        # This forms a directed line graph (no branching, no cycles),
        # guaranteed by the problem. Every city except the very last one
        # has exactly one outgoing path to the next city in the chain.
        # The destination city is the one and only city with out-degree
        # 0, it never appears as a source (cityA) in any path.

        # Rather than counting degrees explicitly, we can just collect
        # every source city into a set, then scan for the one
        # destination city (cityB) that never shows up as a source.

        # Track Source Cities:
        # every city that has at least one outgoing path
        # tc: O(E)
        # sc: O(V)
        sources = set()
        for cityA, cityB in paths:
            sources.add(cityA)

        # Find Out-Degree Zero City:
        # the destination is whichever cityB never appears as a source
        # tc: O(E)
        for cityA, cityB in paths:

            if cityB not in sources:
                return cityB

        # overall: tc O(V + E), two passes over paths
        # overall: sc O(V), for the sources set
        return ""

    def findJudge(self, n: int, trust: List[List[int]]) -> int:
        
        # Note:
        #   We represent trust as a graph where an edge a -> b means a trusts b.
        #   The town judge is the only node with In Degree of (n-1), meaning 
        #   everyone trusts them, and an Out Degree of 0, meaning they trust nobody.
        #   We can track this with a single net score per person instead of using
        #   separate in and out degree counters.
        #   for (a -> b) in trust:
        #       +1 to b's score for incoming trust edges
        #       -1 to a's score for outgoing trust edges
        #   The judge if they exist will have a score of (n-1)

        # Check:
        # Single person, no trust relationships possible or needed,
        # they will always be the judge
        if n == 1 and not trust:
            return 1
        
        # Trust array to track net trust score for each person
        # sc: O(n)
        trustScore = [0] * (n + 1)
        
        # Check every trust relationship and update the trust score accordingly
        #   +1 for every person who trusts i
        #   -1 for every person i trusts
        # tc: O(m)
        for a, b in trust:
            trustScore[a] -= 1
            trustScore[b] += 1
        
        # Check every final trust score to see if any person has a score of (n-1)
        # tc: O(n)
        for person in range(1, n + 1):
            if trustScore[person] == n - 1:
                return person
        
        # overall: tc O(n + m)
        # overall: sc O(n)
        return -1

    def findCelebrity(self, n: int) -> int:

        # Node:
        #   The celebrity, if one exists, is known by everyone but knows no one,
        #   and have in-degree (n-1) and out-degree 0 in a directed graph.
        #   For any pair (a, b), at most one of them can be the celebrity:
        #       - if a knows b, a cannot be the celebrity
        #       - if a does not know b, b cannot be the celebrity
        #   The allows a single pass to eliminate n-1 candidates, leaving 1 to verify.

        # Start with any candidate, and eliminate one person for each comparison
        # until we are left with one candidate
        a = 0

        for b in range(1, n):

            # Check:
            # Person A knows person B, so Person A cannot be the celebrity,
            # we now test Person B
            if knows(a, b):
                a = b

            # Else:
            # Person A did not know Person B, so Person B cannot be the celebrity,
            # we continue to test Person A

        # Person A is the last remaining candidate,
        # for each person other than A, we validate:
        #   - A does not know B
        #   - B knows A
        for b in range(n):

            # Skip A
            if b == a:
                continue

            # If A knows B => A is not the candidate
            # If B does not know A => A is not the candidate
            if knows(a, b) or not knows(b, a):
                return -1

        # A is validated to be the candidate

        # overall: tc O(n)
        # overall: sc O(1)
        return candidate