class Solution:

    def countPoints(self, rings: str) -> int:

        n = len(rings) // 2

        d = defaultdict(set)

        for i in range(n):

            d[rings[2*i+1]].add(rings[2*i])

        ans = 0

        for k, v in d.items():

            if len(v) == 3:

                ans += 1

        return ans

class Solution:

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

        n = len(nums)

        minMat = [[0] * n for _ in range(n)]

        maxMat = [[0] * n for _ in range(n)]

        for i in range(n):

            minMat[i][i] = nums[i]

            maxMat[i][i] = nums[i]

        ans = 0

        for length in range(2, n+1):

            for start in range(0, n-length+1):

                end = start + length - 1

                minMat[start][end] = min(minMat[start][end-1], nums[end])

                maxMat[start][end] = max(maxMat[start][end-1], nums[end])

                ans += maxMat[start][end] - minMat[start][end]

        return ans

class Solution:

    def minimumRefill(self, plants: List[int], capacityA: int, capacityB: int) -> int:

        n = len(plants)

        canA, canB = capacityA, capacityB

        iA, iB = 0, n-1

        ans = 0

        while iA < iB:

            if canA < plants[iA]: canA = capacityA; ans += 1

            if canB < plants[iB]: canB = capacityB; ans += 1

            canA -= plants[iA]; canB -= plants[iB]

            iA += 1; iB -= 1

        if iA == iB:

            if max(canA, canB) < plants[iA]: ans += 1

        return ans

class Solution:

    def maxTotalFruits(self, fruits: List[List[int]], startPos: int, k: int) -> int:

        d = Counter();r = 1;left = Counter();right = Counter()

        for i,j in fruits:  d[i] = j

        ans = d[startPos]

        for i in range(startPos+1,startPos+k+1):

            right[i-startPos] = right[i-1-startPos] + d[i]

        for i in range(startPos - 1,startPos-k-2,-1):

            left[r] = left[r-1] + d[i];r+=1

        for i in range(1,k+1):

            ans = max(ans,max(right[i] + left[k - 2*i],left[i] + right[k - 2*i]) + d[startPos])

        return ans