leetcode 156周赛(python)

Posted xxx_fna

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了leetcode 156周赛(python)相关的知识,希望对你有一定的参考价值。

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

独一无二的出现次数

给你一个整数数组 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 判断太多了。。)

 

以上是关于leetcode 156周赛(python)的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode周赛第 291 场周赛(Go语言实现版)

leetcode179周赛 python解题报告 A,B

LeetCode周赛第 288 场周赛(Go语言实现版)

LeetCode周赛第 288 场周赛(Go语言实现版)

LeetCode周赛第 288 场周赛(Go语言实现版)

LeetCode周赛第 288 场周赛(Go语言实现版)