class Solution:

    def maxSubsequence(self, nums: List[int], k: int) -> List[int]:

        c = Counter(sorted(nums, key=lambda x: -x)[:k])

        ans = []

        for x in nums:

            if c[x]: 

                ans.append(x)

                c[x] -= 1

        return ans

class Solution:

    def goodDaysToRobBank(self, sec: List[int], time: int) -> List[int]:

        n = len(sec)

        ans = []

        k = time

        if 2*k >= n: return []

        ll = lr = k

        rl = rr = 2*k

        while ll > 0 and sec[ll] <= sec[ll-1]: ll -= 1

        while rl > 0 and sec[rl] >= sec[rl-1]: rl -= 1

        for i in range(k, n-k):

            if lr - ll >= k and rr - rl >= k: ans.append(i)

            if i == n-k-1: break

            lr += 1; rr += 1

            if sec[lr] > sec[lr-1]: ll = lr

            if sec[rr] < sec[rr-1]: rl = rr

        return ans

class Solution:

    def maximumDetonation(self, bombs: List[List[int]]) -> int:

        n = len(bombs)

        mat = [[False] * n for _ in range(n)]

        for i in range(n):

            b1 = bombs[i]

            for j in range(n):

                b2 = bombs[j]

                dist = (b1[0] - b2[0]) ** 2 + (b1[1] - b2[1]) ** 2

                if b1[2] ** 2 >= dist:

                    mat[i][j] = True

        for k in range(n):

            for i in range(n):

                for j in range(n):

                    mat[i][j] = mat[i][j] or (mat[i][k] and mat[k][j])

        return max(sum(x) for x in mat)

class Solution:

    def checkIfPrerequisite(self, numCourses: int, prerequisites: List[List[int]], queries: List[List[int]]) -> List[bool]:

        def floydWarshall(reachable, n): 

            for k in range(n): 

                for i in range(n): 

                    for j in range(n): 

                        reachable[i][j] = reachable[i][j] or (reachable[i][k] and reachable[k][j]) 

            return reachable 

        mat = [[False] * numCourses for _ in range(numCourses)] 

        for pre, suc in prerequisites: 

            mat[pre][suc] = True 

        floydWarshall(mat, numCourses) 

        return [mat[query[0]][query[1]] for query in queries]

class SORTracker:

    def __init__(self):

        self.idx = 0

        self.arr = []

    def add(self, name: str, score: int) -> None:

        bisect.insort_right(self.arr, (-score, name))

    def get(self) -> str:

        self.idx += 1

        return self.arr[self.idx-1][1]

# Your SORTracker object will be instantiated and called as such:

# obj = SORTracker()

# obj.add(name,score)

# param_2 = obj.get()