A. Make Array Zero by Subtracting Equal Amounts (opens new window)

Count unique non-zero numbers.

DETAILS

def minimumOperations(self, A: List[int]) -> int:
        return len(set(A)) if 0 not in set(A) else len(set(A)) - 1

B. Maximum Number of Groups Entering a Competition (opens new window)

Binary search.

DETAILS

def maximumGroups(self, A: List[int]) -> int:
        n, l, r = len(A), 1, len(A)
        while l < r:
            m = (l + r + 1) >> 1
            if m * (m + 1) // 2 <= n:
                l = m
            else:
                r = m - 1
        return l

C. Find Closest Node to Given Two Nodes (opens new window)

BFS, find the distance from node A, B to all the other nodes.

DETAILS

def closestMeetingNode(self, E: List[int], n1: int, n2: int) -> int:
        n = len(E)
        d1, d2 = [-1] * n, [-1] * n
        
        dq = collections.deque()
        dq.append(n1)
        
        dist = 0
        while dq:
            cur = dq.popleft()
            d1[cur] = dist
            dist += 1
            if E[cur] != -1:
                nxt = E[cur]
                if d1[nxt] != -1:
                    break
                dq.append(nxt)
        
        dq = collections.deque()
        dq.append(n2)
        dist = 0
        while dq:
            cur = dq.popleft()
            d2[cur] = dist
            dist += 1
            if E[cur] != -1:
                nxt = E[cur]
                if d2[nxt] != -1:
                    break
                dq.append(nxt)
                
        dd, ans = 100010, -1
        for i in range(n):
            if d1[i] != -1 and d2[i] != -1:
                if max(d1[i], d2[i]) < dd:
                    dd = max(d1[i], d2[i])
                    ans = i
        return ans

D. Longest Cycle in a Graph (opens new window)

BFS.

DETAILS

def longestCycle(self, E: List[int]) -> int:     
        n = len(E)
        seen = [-1] * n
        dq = collections.deque()
        ans = -1
        
        for i in range(n):
            if seen[i] == -1:
                dq = collections.deque()
                dq.append([i, 0])
                seen[i] = 0
                cur = set()
                cur.add(i)
                while dq:
                    ci, cd = dq.popleft()
                    seen[ci] = cd
                    if E[ci] != -1:
                        ni = E[ci]
                        if seen[ni] != -1:
                            if ni in cur:
                                ans = max(ans, cd - seen[ni] + 1)
                            break
                        seen[ni] = cd + 1
                        cur.add(ni)
                        dq.append([ni, cd + 1])

        return ans