leetcode 156周赛（python）

Posted 2020-11-15 xxx_fna

两周了，第一次独立写完四个题目，开心（当然... 不是在考试时间内写完的，主要还是四个题知识图谱内，而且还不难吧），加油！

独一无二的出现次数

给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。

如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。

 

示例 1：

输入：arr = [1,2,2,1,1,3]
输出：true
解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。

提示：

• 1 <= arr.length <= 1000
• -1000 <= arr[i] <= 1000

看到范围，直接暴力（经过这两周...我的理解是10^10以内都可以暴力求解）

class Solution:
    def uniqueOccurrences(self, arr: List[int]) -> bool:
        d = dict()
        for i in arr:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1for key,val in d.items():
            for key2,val2 in d.items():
                if key == key2:
                    continue
                if val == val2:
                    return False
        return True

 

尽可能使字符串相等

给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

 

示例 ：

输入：s = "abcd", t = "bcdf", cost = 3
输出：3
解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。

输入：s = "abcd", t = "cdef", cost = 3
输出：1
解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。

提示：

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

如之前所说O(n^2) 会是 10^10要超时，所以换种思路，滑动窗口。

# 写的比较笨拙，见谅哈
class Solution:
    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
        len_s = len(s)
        num = [0 for i in range(len_s)]
        # 记录次数
        for i in range(len_s):
            num[i] = abs(ord(s[i]) - ord(t[i]))
        # 扫描出初始窗口
        tmp = maxCost
        cnt = 0
        for i in range(len_s):
            if tmp - num[i] >= 0:
                tmp -= num[i]
                cnt += 1
            else:
                break
        # 从初始窗口开始扫描，每次删掉窗口头部结点，加入尾部结点
        i = cnt
        while i < len_s:
            tmp += num[i-cnt] # 删掉头部结点
            tmp -= num[i] # 加入尾部结点
            if tmp >= 0: # 如果还可以扩张
                j = i + 1 
                while j < len_s: # 扩张
                    if tmp - num[j] >= 0:
                        tmp -= num[j]
                        cnt += 1
                    else:
                        break
                    j += 1
                i = j
            else:
                i += 1
        return cnt

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

给你一个字符串 s，「k 倍重复项删除操作」将会从 s 中选择 k 个相邻且相等的字母，并删除它们，使被删去的字符串的左侧和右侧连在一起。

你需要对 s 重复进行无限次这样的删除操作，直到无法继续为止。

在执行完所有删除操作后，返回最终得到的字符串。

本题答案保证唯一。

 

示例：

输入：s = "abcd", k = 2
输出："abcd"
解释：没有要删除的内容。

输入：s = "deeedbbcccbdaa", k = 3
输出："aa"
解释： 
先删除 "eee" 和 "ccc"，得到 "ddbbbdaa"
再删除 "bbb"，得到 "dddaa"
最后删除 "ddd"，得到 "aa"

输入：s = "pbbcggttciiippooaais", k = 2
输出："ps"

 

提示：

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

看到题目第一反应是模拟栈 ，看到10^5...我就怕了...  然后...想不出啥来，抱着试一试的态度用了一个list去标记每一轮要删除的数组位置，

然后逐个删除（并不比模拟栈复杂度低，我心里想着至少这个没有压栈出栈的操作），但是居然过了... 交的时候还双手合十祈祷来着~

class Solution:
    def removeDuplicates(self, s: str, k: int) -> str:
        s = list(s)
        while True:
            len_s = len(s)
            if len_s < k:
                return \'\'.join(s)
            
            i = 0
            de = [] # 重复字符的索引标记数组
            while i < len(s) - k + 1:
                flag = 1 # 用来标记是否找到k个重复字符
                j = 1
                while j < k:
                    if s[i] != s[i + j]:
                        flag = 0
                        break
                    j += 1
                if flag:
                    de.append([i, i + j])
                i += j
                
            cnt = 0 # 标记删除了多少个
            for st, ed in de:
                s = s[:st - cnt] + s[ed - cnt:]
                cnt += ed - st
            if not de: # 没有找到一个k重复字符
                return \'\'.join(s)

穿过迷宫的最少移动次数

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

我们在一个 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)）。
  
• 如果它处于竖直状态并且其右面的两个单元都是空的，就逆时针旋转 90 度。蛇从（(r, c)、(r+1, c)）移动到（(r, c)、(r, c+1)）。
  

返回蛇抵达目的地所需的最少移动次数。

如果无法到达目的地，请返回 -1。

示例

 

 

输入：grid = [[0,0,0,0,0,1],
               [1,1,0,0,1,0],
               [0,0,0,0,1,1],
               [0,0,1,0,1,0],
               [0,1,1,0,0,0],
               [0,1,1,0,0,0]]
输出：11
解释：
一种可能的解决方案是 [右, 右, 顺时针旋转, 右, 下, 下, 下, 下, 逆时针旋转, 右, 下]。

 

这个题目看到的第一反应就是大一懵懵懂懂遇到的走迷宫了，BFS。 注意两个格子、只会右、下、旋转。

import queue

class Solution:
    def minimumMoves(self, grid: List[List[int]]) -> int:
        # 横 -- 0  竖 | 1
        n = len(grid)
        q = queue.Queue()
        vis = {} # 标记是否访问过
        #[point1, point2, 状态, 步数]
        q.put([(0,0),(0,1), False, 0])
        
        status = count = 0
        while not q.empty():
            [p1, p2, status, count] = q.get()
            if (p1,p2) in vis: # 如果访问过比较一下。
                vis[p1,p2] = min(count, vis[p1,p2])
                continue
            else:
                vis[p1, p2] = count
            if not status: # 横着的
                if p2[1] + 1 < n and grid[p2[0]][p2[1]+1] == 0: # 右移
                    q.put([p2,(p2[0],p2[1]+1), status, count+1])
                       
                if p1[0] + 1 < n and grid[p1[0]+1][p1[1]] == 0 and grid[p2[0]+1][p2[1]] == 0:
                    q.put([p1, (p1[0]+1,p1[1]), not status, count+1]) # 旋转
                    q.put([(p1[0]+1,p1[1]), (p2[0]+1,p2[1]), status, count+1]) # 下移
            else: # 竖着的
                if p2[0] + 1 < n and grid[p2[0]+1][p2[1]] == 0:
                    q.put([p2,(p2[0]+1,p2[1]), status, count+1]) # 下移
                    
                if p1[1] + 1 < n and grid[p1[0]][p1[1]+1] == 0 and grid[p2[0]][p2[1]+1] == 0: 
                    q.put([p1, (p1[0],p1[1]+1), not status, count+1]) # 旋转
                    q.put([(p1[0],p1[1]+1), (p2[0],p2[1]+1), status, count+1]) # 右移
        
        if ((n-1,n-2),(n-1,n-1)) in vis:
            return vis[(n-1,n-2),(n-1,n-1)]
        else:
            return -1

 

总结： 

　　代母写的还是不够节俭，有时候思路很乱。 稍微复杂的题目脑袋瓜子在DFS的时候 回不到原点了~ 

　　最后一题完全可以在规定时间内写出来，在判断是否已经访问过的时候，居然在for循环内部判断，

　　想着队列里的点都是没访问过的结点，结果超时了。。（if 判断太多了。。）