1207. 独一无二的出现次数

给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。

暴力统计输出结果即可

class Solution(object):
    def uniqueOccurrences(self, arr):

        """
        :type arr: List[int] :rtype: bool
        """
        mp = {}
        for i in arr:
            mp[i] = mp.get(i, 0) + 1
        ans = []
        for k, v in mp.items():
            ans.append(v)
        return len(set(ans)) == len(ans)

1208. 尽可能使字符串相等

给你两个长度相同的字符串，s 和 t。
将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。
用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。
如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。
如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。
提示：

• 1 <= s.length, t.length <= 10^5
• 0 <= maxCost <= 10^6
• s 和 t 都只含小写英文字母。

s,t字符串长度都比较长,所以考虑O(n)的解法尺取法.写法不是很优美,准备最近更改一下双while

class Solution(object):
    def equalSubstring(self, s, t, maxCost):
        """
        :type s: str
        :type t: str
        :type maxCost: int
        :rtype: int
        """
        l, r = 0, 0
        ans, nowcost = 0, 0
        length = len(s)
        while l <= r and r < length:
            if nowcost <= maxCost and r < length:
                ans = max(r - l, ans)
                nowcost += abs(ord(s[r]) - ord(t[r]))
                r += 1
            if nowcost <= maxCost:
                ans = max(r - l, ans)
            while nowcost > maxCost and l <= r:
                nowcost -= abs(ord(s[l]) - ord(t[l]))
                l += 1
        return ans

1209. 删除字符串中的所有相邻重复项 II

给你一个字符串 s，「k 倍重复项删除操作」将会从 s 中选择 k 个相邻且相等的字母，并删除它们，使被删去的字符串的左侧和右侧连在一起。
你需要对 s 重复进行无限次这样的删除操作，直到无法继续为止。
在执行完所有删除操作后，返回最终得到的字符串。
本题答案保证唯一。
提示：

• 1 <= s.length <= 10^5
• 2 <= k <= 10^4
• s 中只含有小写英文字母。

考虑维护一个栈每次删除的时候都是更新栈顶,如果栈顶被删除就继续更新新的栈顶,然后答案再将栈从底部到顶连在一起

class Solution(object):
    def removeDuplicates(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        stack = []
        for i in s:
            if stack and stack[-1][0] == i:
                stack[-1][1] += 1
            else:
                stack.append([i,1])
            while stack and stack[-1][1]>=k:
                tmp = stack[-1][1]%k
                if tmp :
                    stack[-1][1] = tmp
                else:
                    stack.pop()
        ans = ""
        for arr in stack:
            ans += arr[0]*arr[1]
        return ans

1210. 穿过迷宫的最少移动次数

你还记得那条风靡全球的贪吃蛇吗？

我们在一个 n*n 的网格上构建了新的迷宫地图，蛇的长度为 2，也就是说它会占去两个单元格。蛇会从左上角（(0, 0) 和 (0, 1)）开始移动。我们用 0 表示空单元格，用 1 表示障碍物。蛇需要移动到迷宫的右下角（(n-1, n-2) 和 (n-1, n-1)）。

每次移动，蛇可以这样走：

• 如果没有障碍，则向右移动一个单元格。并仍然保持身体的水平／竖直状态。
• 如果没有障碍，则向下移动一个单元格。并仍然保持身体的水平／竖直状态。
• 如果它处于水平状态并且其下面的两个单元都是空的，就顺时针旋转 90 度。蛇从（(r, c)、(r, c+1)）移动到 （(r, c)、(r+1, c)）。

本质上还是深度优先搜索的题,状态比较恶心繁琐.待补