progchan

class Solution:
    def isZeroArray(self, nums: List[int], queries: List[List[int]]) -> bool:
        diff = [0] * (len(nums)+1)
        for l,r in queries:
            diff[l] += 1
            diff[r+1] -= 1
        max_diff = 0
        for i, n in enumerate(nums):
            max_diff += diff[i]
            if n - max_diff > 0:
                return False
        return True

def findGroups(isConnected: List[List[int]]) -> int:
    count = len(isConnected)
    parent = list(range(count))
    rank = [1] * count
    def find(i):
        if parent[i] != i:
            parent[i] = find(parent[i])
        return parent[i]
    def union(i,j):
        nonlocal count
        pi = find(i)
        pj = find(j)
        if pi == pj:
            return
        count -= 1
        if rank[pi] > rank[pj]:
            parent[pj] = pi
            rank[pi] += rank[pj]
        else:
            parent[pi] = pj
            rank[pj] += rank[pi]
    for i in range(n):
        for j in range(n):
            if isConnected[i][j]:
                union(i,j)
    return count

def polygon_area(points: List[List[int]]) -> int:
    n = len(points)
    area = 0
    for i in range(n):
        x1, y1 = points[i]
        x2, y2 = points[(i + 1) % n]  # wrap around
        area += x1 * y2 - x2 * y1
    return abs(area) / 2

def topological_sort(edges: List[List[int]]) -> List[int]:
    res = []
    nodes = {x for y in edges for x in y}
    adj = {x:set() for x in nodes}
    for a, b in edges:
        adj[a].add(b)
    visited = {x:0 for x in nodes}
    def dfs(i):
        if visited[i] == 1:
            return False
        if visited[i] == 2:
            return True
        visited[i] = 1
        for n in adj[i]:
            if not dfs(n):
                return False
        visited[i] = 2
        res.append(i)
        return True
    for n in nodes:
        if not dfs(n):
            return []
    return res
topological_sort([[5,4], [4,3], [2,1]]) # [1, 2, 3, 4, 5]