def findCenter(self, edges: List[List[int]]) -> int:
        
        # Note:
        # Finding the center of a star graph
        # using an Edge List

        # Edge List:
        # edges = [
        #     [1, 2],
        #     [2, 3],
        #     [4, 2],
        # ]

        # In a star graph, every single edge touches the center node,
        # since the center connects to every other node directly. That
        # means the center is guaranteed to appear in EVERY edge, so we
        # never need to scan the whole edge list or count degrees at all,
        # we only need to look at the first two edges.

        # The center is whichever node is shared between edge 0 and
        # edge 1. Any node that appears in both must be the center,
        # since a non-center (leaf) node only ever appears in exactly
        # one edge (its single connection to the center).

        # Grab First Two Edges:
        # tc: O(1)
        u1, v1 = edges[0]
        u2, v2 = edges[1]

        # Shared Node Check:
        # if either node from edge 0 also appears in edge 1, it's the center
        if u1 == u2 or u1 == v2:
            return u1

        # overall: tc O(1)
        # overall: sc O(1)
        return v1

    def maximalNetworkRank(self, n: int, roads: List[List[int]]) -> int:
        
        # Note:
        # Maximal Network Rank is a degree-counting problem, not a
        # connectivity problem, so DFS/BFS/Union-Find don't apply here.
        # We never need to traverse beyond a node's immediate neighbors.

        # Edge List:
        # roads = [
        #     [0, 1],
        #     [0, 2],
        #     [1, 2],
        # ]

        # The network rank of two cities is the total number of roads
        # touching either city, counted once each even if both cities
        # share a direct road between them.

        # Precompute Degree Array:
        # degree[i] = number of roads touching city i
        # tc: O(E)
        # sc: O(V)
        degree = [0] * n
        for u, v in roads:
            degree[u] += 1
            degree[v] += 1

        # Precompute Adjacency Set:
        # for O(1) "are these two cities directly connected" checks
        # sc: O(E)
        connected = set()
        for u, v in roads:
            connected.add((u, v))
            connected.add((v, u))

        # Check All Pairs:
        # tc: O(V^2)
        maxRank = 0

        for i in range(n):
            for j in range(i + 1, n):

                # Network Rank Formula:
                # sum of both degrees, minus 1 if directly connected
                # (a shared road would otherwise be double counted)
                rank = degree[i] + degree[j]

                if (i, j) in connected:
                    rank -= 1

                maxRank = max(maxRank, rank)

        # overall: tc O(V^2 + E), V^2 for the pairwise scan (dominates
        #   for dense graphs), E for building degree/adjacency structures
        # overall: sc O(V + E), for the degree array and adjacency set
        return maxRank