leetcode刷题记录50-100-基于python

最新推荐文章于 2023-04-05 17:34:40 发布
最新推荐文章于 2023-04-05 17:34:40 发布
阅读量299 收藏
点赞数
文章标签： python 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_28015305/article/details/115495766
版权

51. N 皇后-Hard

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        self.res = []
        trans = lambda path : ['.' * i +  'Q' + '.'*(len(path) - 1 - i) for i in path]
        def recursion(n, path, pos):
            if len(path) == n:
                self.res.append(trans(path))
                return
            l, r, m = pos
            l, r = [i-1 for i in l], [i + 1 for i in r]
            total = l + r + m
            for cand in range(n):
                if  cand in total:
                    continue
                recursion(n, path + [cand], [l + [cand], r + [cand], m + [cand]])
        recursion(n, [], [[], [], []])
    	return self.res

52. N皇后 II-Hard

class Solution:
    def totalNQueens(self, n: int) -> int:
        self.res = []
        trans = lambda path : ['.' * i +  'Q' + '.'*(len(path) - 1 - i) for i in path]
        def recursion(n, path, pos):
            if len(path) == n:
                self.res.append(trans(path))
                return
            l, r, m = pos
            l, r = [i-1 for i in l], [i + 1 for i in r]
            total = l + r + m
            for cand in range(n):
                if  cand in total:
                    continue
                recursion(n, path + [cand], [l + [cand], r + [cand], m + [cand]])
        recursion(n, [], [[], [], []])
        return len(self.res)

或

class Solution:
    def totalNQueens(self, n: int) -> int:
        self.res = 0
        def recursion(path, pos):
            if len(path) == n:
                self.res += 1
                return
            l, r = pos
            l, r = [i-1 for i in l], [i + 1 for i in r]
            total = l + r + path
            for cand in range(n):
                if  cand in total:
                    continue
                recursion(path + [cand], [l + [cand], r + [cand]])
        for i in range(n // 2):
            recursion([i], [[i], [i]])
        self.res *= 2
        if n % 2:
            recursion([n // 2], [[n // 2], [n // 2]])
        return self.res

53. 最大子序和-Easy

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        # 若list 中所有数均小于0
        if max(nums) < 0:
            return max(nums)
        local_max, global_max = 0, 0
        for num in nums:
            local_max = max(0, local_max + num)
            global_max = max(global_max, local_max)
        return global_max

54. 螺旋矩阵-Medium

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        # matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
        # 获取行数
        row = len(matrix)
        if row == 0 or len(matrix[0]) == 0:
            return []
        # 获取列数
        col = len(matrix[0])
        # 第一行为
        res = matrix[0]
        
        if row > 1:
            # 获取最后一列 8, 12
            for i in range(1, row):
                res.append(matrix[i][col - 1])
            # 获取最后一行 11， 10 ，9
            for j in range(col - 2, -1, -1):
                res.append(matrix[row -1][j])
            if col > 1:
                # 获取5
                for i in range(row - 2, 0, -1):
                    res.append(matrix[i][0])
        # 将剩下的 6， 7 作为新list 递归进spiralOrder
        M = []
        for k in range(1, row - 1):
            t = matrix[k][1:-1]
            M.append(t)
        return res + self.spiralOrder(M)

55. 跳跃游戏 - Medium

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        n = len(nums)
        reach = 0
        for i in range(n):
            if reach >= n - 1 or reach < i:
                break
            reach = max(reach, nums[i] + i)
        return reach >= n - 1

56. 合并区间-Medium

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        result = []
        intervals.sort(key = lambda x : x[0])
        i = 0
        while i < len(intervals):
            cur_start = intervals[i][0]
            cur_end = intervals[i][1]
            if result:
                prev_start, prev_end = result[-1]
                hi = min(prev_end, cur_end)
                lo = max(prev_start, cur_start)

                if lo <= hi:
                    if cur_end > prev_end:
                        result[-1][1] = cur_end
                else:
                    result.append(intervals[i])
            else:
                intervals.append(intervals[i])
            i += 1
        return result

或

class Solution:
    def merge(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[Interval]
        """
        if not intervals:
            return []
        intervals.sort(key=lambda x: x[0])
        pre, cur, n = 0, 1, len(intervals)
        while cur < n:
            if intervals[pre][1] < intervals[cur][0]:
                pre += 1
                intervals[pre] = intervals[cur]
            else:
                intervals[pre][1] = max(intervals[pre][1], intervals[cur][1])
            cur += 1

        return intervals[:pre+1]

57. 插入区间-Medium

class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        index = 0
        while(index < len(intervals) and newInterval[0] > intervals[index][0]):
            index += 1
        intervals.insert(index, newInterval)
        res = []
        last = None
        for interval in intervals:
            if not last or last[1] < interval[0]:
                res.append(interval)
                last = interval
            else:
                last[1] = max(last[1], interval[1])
        return res

58. 最后一个单词的长度-Easy

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        count = 0
        local_count = 0
        for i in range(len(s)):
            if s[i] == ' ':
                local_count = 0
            else:
                local_count += 1
                count = local_count
        return count

59. 螺旋矩阵 II-Medium

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        # 初始化结果矩阵
        matrix = []
        for i in range(n):
            matrix.append([0 for j in range(n)])
        # 初始化行，列索引和值
        rowBegin = 0
        rowEnd = n - 1
        colBegin = 0
        colEnd = n - 1
        number = 1
        
        while colBegin <= colEnd and rowBegin <= rowEnd:
            # 对第一行赋值
            for i in range(colBegin, colEnd + 1):
                matrix[rowBegin][i] = number
                number += 1
            rowBegin += 1
        
            # 对最后一列赋值
            for i in range(rowBegin, rowEnd + 1):
                matrix[i][colEnd] = number
                number += 1
            colEnd -= 1

            # 最后一行
            if rowBegin <= rowEnd:
                for i in range(colEnd, colBegin - 1, -1):
                    matrix[rowEnd][i] = number
                    number += 1
                rowEnd -= 1

            # 最后的行
            if colBegin <= colEnd:
                for i in range(rowEnd, rowBegin - 1, -1):
                    matrix[i][colBegin] = number
                    number += 1
                colBegin += 1
        return matrix

60. 排列序列-Hard

class Solution:
    def getPermutation(self, n: int, k: int) -> str:
        ans = ''
        digits = [i for i in range(1, n + 1)]
        for i in range(n -1 , -1, -1):
            curbase = math.factorial(i)
            curindex = (k - 1) // curbase
            ans += str(digits[curindex])
            digits.remove(digits[curindex])
            k = k - curindex * curbase
        return ans

61. 旋转链表-Medium

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: ListNode, k: int) -> ListNode:
        # 链表长度大于2才可以旋转
        if head is None or head.next is None:
            return head
        # 计算链表长度
        n = 0
        p = head
        while p:
            n += 1
            p = p.next

        # 用k对n进行取余,判断实际需要移动几次（每n次和原链表形状一致）
        k = k % n
        if k == 0:
            return head

        # 计算要移动的位置
        p1, p2 = head, head 
        for i in range(k):
            p2 = p2.next
        while p2 and p2.next:
            p1 = p1.next
            p2 = p2.next
        # 旋转链表
        output = p1.next
        p1.next = None
        p2.next = head
        return output

62. 不同路径-Medium

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # 初始化第一行及第一列全为1
        # 剩余格子值为该格子相邻左边、上边格子的和
        # 依次更新第二行，第三行
        if m == 0 or n == 0:
            return 1
        # 初始化时候可以将list全部初始化为1，再计算除了第一行第一列的值
        cache = [[1] * n for _ in range(m)]
        # print(cache)
        # [[1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1]]
        for i in range(1, m):
            for j in range(1, n):
                cache[i][j] = cache[i - 1][j] + cache[i][j - 1]
        return cache[-1][-1]

或

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        # 或者采用排列组合，先计算到达目的地需要多少次右边n和多少次向下m移动
        # 如题目中，需要进行6次右，2次下
        # C(2, 8) / C(6, 8)
        res = 1
        div = 1
        for i in range(m, m+n-1):
            res *= i
            div *= (i - m + 1)
        return res // div

63. 不同路径 II-Medium

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        # 初始化第一行全为1, 遇到障碍物，障碍物及右边的所有格子为0
        # 再更新第二行第一列为1
        # 第二行剩余格子值为该格子相邻左边、上边格子的和
        # 依次更新第三行
        if not obstacleGrid:
            return 0
        m, n = len(obstacleGrid), len(obstacleGrid[0])
        cache = [[0] * n for _ in range(m)]
        cache[0][0] = 1
        for i in range(m):
            for j in range(n):
                # 遇到障碍物
                if obstacleGrid[i][j] == 1:
                    cache[i][j] = 0
                else:
                    if i > 0:
                        cache[i][j] += cache[i - 1][j]
                    if j > 0:
                        cache[i][j] += cache[i][j - 1]
        return cache[-1][-1]

64. 最小路径和-Medium

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        if not grid:
            return 0
        # 采用动态规划思想
        # 初始化动态规划list, 外加一层padding
        dp = [[2**31-1 for _ in range(len(grid[0]) + 1)] for _ in range(len(grid) + 1)] 
        for i in range(1, len(grid) + 1):
            for j in range(1, len(grid[0]) + 1):
                if i == 1 and j == 1:
                    dp[i][j] = grid[i - 1][j - 1]
                    continue
                # 动态规划方程
                dp[i][j] = grid[i - 1][j - 1] + min(dp[i - 1][j], dp[i][j - 1])
        return dp[-1][-1]

65. 有效数字-Hard

这道题应该难在考虑各种情况。所有的字符可以分为六大类，空格，符号，数字，小数点，自然底数和其他字符，我们需要五个标志变量，num, dot, exp, sign分别表示数字，小数点，自然底数和符号是否出现，numAfterE表示自然底数后面是否有数字，那么我们分别来看各种情况：

- 空格： 我们需要排除的情况是，当前位置是空格而后面一位不为空格，但是之前有数字，小数点，自然底数或者符号出现时返回false。

- 符号：符号前面如果有字符的话必须是空格或者是自然底数，标记sign为true。

- 数字：标记num和numAfterE为true。

- 小数点：如果之前出现过小数点或者自然底数，返回false，否则标记dot为true。

- 自然底数：如果之前出现过自然底数或者之前从未出现过数字，返回false，否则标记exp为true，numAfterE为false。

- 其他字符：返回false。

最后返回num && numAfterE即可。

class Solution:
    def isNumber(self, s: str) -> bool:
        try:
            float(s)
            return True
        except:
            return False

或

class Solution(object):
    def isNumber(self, s):
        """
        :type s: str
        :rtype: bool
        """
        if not s:
            return False
        INVALID = 0
        SPACE = 1
        SIGN = 2
        DIGIT = 3
        DOT = 4
        E = 5
 
        transition = [
            [-1,0,3,1,2,-1],
            [-1,8,-1,1,4,5],
            [-1,-1,-1,4,-1,-1],
            [-1,-1,-1,1,2,-1],
            [-1,8,-1,4,-1,5],
            [-1,-1,6,7,-1,-1],
            [-1,-1,-1,7,-1,-1],
            [-1,8,-1,7,-1,-1],
            [-1,8,-1,-1,-1,-1]
        ]
 
        state = 0
        for i in s:
            if i == ' ':
                idx = SPACE
            elif i == '-' or i == '+':
                idx = SIGN
            elif i >= '0' and i <= '9':
                idx = DIGIT
            elif i == '.':
                idx = DOT
            elif i == 'E' or i == 'e':
                idx = E
            else:
                idx = INVALID
            state = transition[state][idx]
            if state == -1:
                return False
        return state == 1 or state == 4 or state == 7 or state == 8

66. 加一-Easy

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        if digits[-1] == 9:
            flag = 1
        else:
            flag = 0
        for i in range(len(digits)-1, -1, -1):
            if i == len(digits)-1:
                flag = 1
            if digits[i] + flag > 9:
                digits[i] = 0
                flag = 1
            else:
                digits[i] = digits[i]+flag
                flag = 0
        if flag:
            digits.insert(0,1)
        return digits

或

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in reversed(range(len(digits))):
            if digits[i] == 9:
                digits = 0
            else:
                digits[i] += 1
                return digits
        # input : 9 -> output : 10
        digits[0] = 1
        digits.append(0)
        return digits

67. 二进制求和-Easy

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        result, carry, val = '', 0, 0
        for i in range(max(len(a), len(b))):
            val = carry
            if i < len(a):
                val += int(a[-(i + 1)])
            if i < len(b):
                val += int(b[-(i + 1)])
            carry, val = val // 2, val % 2
            result += str(val)
        if carry:
            result += str(1)
        return result[::-1]

68. 文本左右对齐-Hard

class Solution:
    def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:
        # res: 返回结果
        # line: 缓存每一行单词
        # counter: 统计当前进入line的单词总长度
        res, line, counter = [], [], 0
        for word in words:
            # 采用贪心策略，每一行尽可能多放
            if counter + len(word) + len(line) > maxWidth:
                # 一行放不下时候，另起一行
                for i in range(maxWidth - counter):
                    line[i % max(len(line) - 1, 1)] += ' '
                res.append(''.join(line))
                line, counter = [], 0
            line += [word]
            counter += len(word)
        # ljust()左对齐
        return res + [' '.join(line).ljust(maxWidth)]

69. x 的平方根-Easy

class Solution:
    def mySqrt(self, x: int) -> int:
        if x < 2:
            return x
        left, right = 1, x // 2
        while left <= right:
            mid = left + (right - left) // 2
            if mid > x / mid:
                right = mid - 1
            else:
                left = mid + 1
        return left - 1

70. 爬楼梯-Easy

class Solution:
    def climbStairs(self, n: int) -> int:
        # n = 1, 1种
        # n = 2, 2种
        # n = 3, 3种
        # ....
        # n = n , n + n - 1种
        # 斐波那契数列(结果 = 前两个结果之和)
        prev, current = 0, 1
        for i in range(n):
            prev, current = current, prev + current
        return current

71. 简化路径-Medium

class Solution:
    def simplifyPath(self, path: str) -> str:
        result = []
        path_list = path.split('/')
        for p in path_list:
            if p:
                if p == '..':
                    if result:
                        result.pop()
                elif p == '.':
                    continue
                else:
                    result.append(p)
        res = '/' + '/'.join(result)
        return res

72. 编辑距离-Hard

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        #  topens 用于堆放(word1*, word2*..)
        # visited 用于存放已见过的(word1*, word2*..)词语对
        # 用删除的方式，把已经匹配好的word1*, word2*字母删去，
        # 三种基本操作
        # word1*删去头字母
        # word2*删去头字母
        # 两词同时删去头字母
        w1, w2, opened = word1, word2, set()
        topens = [(w1, w2, 0)]
        while True:
            (w1, w2, value) = topens.pop(0)
            if (w1, w2) in opened:
                continue
            if w1 == w2:
                return value
            opened.add((w1, w2))
            while w1 and w2 and w1[0] == w2[0]:
                w1, w2 = w1[1:], w2[1:]
            value += 1
            topens += [(w1[1:], w2, value),
                        (w1, w2[1:], value),
                        (w1[1:], w2[1:], value)
            ]
        return -1

73. 矩阵置零-Medium

class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        m, n = len(matrix), len(matrix[0])
        zero_row, zero_col = False, False
        for i in range(m):
            for j in range(n):
                if matrix[i][j] == 0:
                    matrix[i][0] = matrix[0][j] = 0
                    zero_row = True if i == 0 else zero_row
                    zero_col = True if j == 0 else zero_col
        
        for j in range(1, n):
            if matrix[0][j] == 0:
                for i in range(1, m):
                    matrix[i][j] = 0
        for i in range(1, m):
            if matrix[i][0] == 0:
                for j in range(1, n):
                    matrix[i][j] = 0
                
        if zero_row:
            for j in range(n):
                matrix[0][j] = 0
            
        if zero_col:
            for i in range(m):
                matrix[i][0] = 0

        return

74. 搜索二维矩阵-Medium

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        # 升序矩阵，采用二分法
        m, n = len(matrix), len(matrix[0])
        if m == 0:
            return False
        left = 0
        right = m * n
        while left < right:
            mid = (left + right) // 2
            i = mid // n
            j = mid % n
            if matrix[i][j] < target:
                left = mid + 1
            elif matrix[i][j] > target:
                right = mid
            else:
                return True
        return False

75. 颜色分类-Medium

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        p, q = 0, 0
        k = len(nums) - 1
        while q <= k:
            if p < q and nums[q] == 0:
                nums[p], nums[q] = nums[q], nums[p]
                p += 1
            elif nums[q] == 2:
                nums[q], nums[k] = nums[k], nums[q]
                k -= 1
            else:
                q += 1

76. 最小覆盖子串-Hard

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        # 创建一个键值对,统计每个字符出现次数
        d = dict(collections.Counter(t)) # {'A':0, 'B':1...}
        # 用于描述ABC中多少字符满足要求
        formed = 0
        # 左指针
        slow = 0
        # 记录最短长度及substring
        min_str = None
        min_length = sys.maxsize - 1
        for fast in range(len(s)):
            ch = s[fast]
            fast += 1
            if ch not in d:
                continue
            # 更新词频
            d[ch] -= 1
            if d[ch] == 0:
                formed += 1
            while formed == len(d) and slow <= fast:
                curr_length = fast - slow 
                if curr_length < min_length:
                    min_length = curr_length
                    min_str = s[slow:fast]
                # 更新左边界
                ch = s[slow]
                slow += 1
                if ch not in d:
                    continue
                d[ch] += 1
                if d[ch] == 1:
                    formed -= 1
        return min_str if min_str is not None else ''

77. 组合-Medium

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        import itertools
        return list(itertools.combinations(range(1, n + 1), k))

或

class Solution:
	def combine(self, n, k):
		ans = []
		nums = [i + i for i in range(n)]
		def dfs(last, now):
			if len(now) == k:
				ans.append(now)
			for i in range(len(last)):
				dfs(last[i + 1:], now + [last[i]])
		dfs(nums, [])
	return ans

78. 子集-Medium

#方法1：递归方法，[1,2,3] --> （[1] + [2,3]子集)+[2,3]子集
class Solution:
    def subsets(self, nums) :
        res = []
        if not nums:
            return [[]]
        else:
            sub = self.subsets(nums[1:])
            res = res + sub
            for s in sub:
                res.append(nums[:1]+s)
        return res

或

#方法2 位运算方法：对每一位为1的表示这一位的数字存在，例如对于输入[1,2,3] 编码i=001，表示只含有3，编码i=101.表示含有1,3
class Solution:
    def subsets(self, nums):
        t=len(nums)
        res=[]
        for i in range(2**t):
            tmp=[]
            for j in range(t):
                if i&(1<<j):
                    tmp.append(nums[t-1-j])
            res.append(tmp)
        return res
 
#方法三 排列组合
class Solution:
    def subsets(self, nums):
        from itertools import combinations
        print([list(s) for s in list(combinations(nums, 2))])
        return sum([list(combinations(nums, i)) for i in range(len(nums) + 1)], [])
 
#方法四：遇到一个数添加一下
class Solution:
    def subsets(self, nums):
        res = []
        res.append([])
        for x in nums:
            new = [s+ [x] for s in res]
            res = res + new
        return res
#方法五：回溯方法 https://leetcode-cn.com/problems/subsets/solution/hui-su-jie-fa-by-jawhiow/
class Solution(object):
    def __init__(self):
        self.result_all = None
 
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        self.result_all = []
        self.dfs(nums, 0, 0, [])
        return self.result_all
 
    def dfs(self, nums, n, start, result):
        self.result_all.append(result[:])
        if len(nums) == n:
            return
 
        for i in range(start, len(nums)):
            result.append(nums[i])
            self.dfs(nums, n + 1, i + 1, result)
            result.pop()
        return

79. 单词搜索-Medium

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        for i in range(len(board)):
            for j in range(len(board[0])):
                # helper(board, i, j, word本身, word索引)
                if self.helper(board, i, j, word, 0):
                    return True
        return False

    
    def helper(self, board, i, j, word, wordIndex):
        # 说明已经找到了答案
        if wordIndex == len(word):
            return True
        # board[0, x] 或者 board[x, len(board)]等边界情况及查找结果不匹配
        if i < 0 or i >= len(board) or j < 0 or j >= len(board[0]) or word[wordIndex] != board[i][j]:
            return False
        # 避免每个字母使用多次,用特殊字母标记
        board[i][j] = '#'
        # 开始上下左右查找
        found = self.helper(board, i + 1, j, word, wordIndex + 1)\
                or self.helper(board, i, j + 1, word, wordIndex + 1)\
                or self.helper(board, i - 1, j, word, wordIndex + 1)\
                or self.helper(board, i, j - 1, word, wordIndex + 1)
        # 查找完后，复原标记
        board[i][j] = word[wordIndex]
        return found

80. 删除有序数组中的重复项 II-Medium

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 满足新要求的数组索引
        j = 0
        # 用于遍历索引
        i = 0
        count = 1
        while i < len(nums):
            if i < len(nums) - 1 and nums[i] == nums[i + 1]:
                count += 1
            else:
                # 插入j为末尾的新标记数组
                d = min(count, 2)
                for k in range(d):
                    nums[j] = nums[i]
                    j += 1
                # 新的起点
                count = 1
            # 下一个判断索引
            i += 1
        return len(nums[:j])

81. 搜索旋转排序数组 II-Medium

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        # num_len = len(nums)
        # if num_len == 0:
        #     return False
        # mid = num_len // 2
        # result = False
        # if nums[mid] == target:
        #     return True
        # elif num_len == 1:
        #     return target == nums[0]
        # elif target > nums[mid]:
        #     if mid > 0 and (nums[mid - 1] > nums[mid] or nums[0] > nums[mid]):
        #         result = self.search(nums[:mid], target)
        #     return result if result is True else self.search(nums[mid+1:], target)
        # else:
        #     if mid < num_len - 1 and (nums[mid] > nums[mid + 1] or nums[mid+1] > nums[-1]):
        #         result = self.search(nums[mid+1:], target)
        #     return result if result is True else self.search(nums[:mid], target)
        left = 0
        right = len(nums)-1
        while left <= right:
            mid = (left+right)//2
            if nums[mid]==target:
                return True
            if nums[mid] == nums[left] == nums[right]:
                left += 1
                right -= 1
            elif nums[mid]>=nums[left]:
                if nums[left]<=target<=nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
                if nums[mid]<=target<=nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1

        return False

82. 删除排序链表中的重复元素 II-Medium

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        if head == None or head.next == None:
            return head
        tmp = ListNode(-1)
        slow = tmp
        fast = head
        while fast:
            if fast.next and fast.val == fast.next.val:
                ee = fast.val
                while fast and ee == fast.val:
                    fast = fast.next
            else:
                slow.next = ListNode(fast.val)
                slow = slow.next
                fast = fast.next
        return tmp.next

83. 删除排序链表中的重复元素-Easy

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        current = head
        while current:
            runner = current.next
            while runner and runner.val == current.val:
                runner = runner.next
            current.next = runner
            current = runner
        return head

84. 柱状图中最大的矩形-Hard

class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:
        # 定义栈
        stack = []
        # 加上首尾标记处理特殊情况
        heights = [0] + heights + [0]
        res = 0
        for i in range(len(heights)):
            while stack and heights[i] < heights[stack[-1]]:
                # 找到最大栈顶元素
                top = stack.pop()
                # 该元素右侧
                r = i - 1
                # 该元素左侧
                l = stack[-1] + 1
                # 计算面积
                area = (r - l + 1) * heights[top]
                res = max(area, res)
            stack.append(i)
        return res

85. 最大矩形-Hard

class Solution:
    def maximalRectangle(self, matrix: List[List[str]]) -> int:
        res = 0
        for i, row in enumerate(matrix):
            if i == 0:
                _heights = [int(ch == '1') for ch in row]
            else:
                for j in range(len(row)):
                    if row[j] == '0':
                        _heights[j] = 0
                    else:
                        _heights[j] += 1
            stack = []
            height = [0] + _heights + [0]
            for j in range(len(height)):
                while stack and height[j] < height[stack[-1]]:
                    top = stack.pop()
                    l = stack[-1] + 1
                    r = j - 1
                    area = (r - l + 1) * height[top]
                    res = max(area, res)
                stack.append(j)
        return res

86. 分隔链表-Medium

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def partition(self, head: ListNode, x: int) -> ListNode:
        dummySmaller, dummyGreater = ListNode(-1), ListNode(-1)
        smaller, greater = dummySmaller, dummyGreater
        while head:
            if head.val < x:
                smaller.next = head
                smaller = smaller.next
            else:
                greater.next = head
                greater = greater.next
            head  = head.next
        smaller.next = dummyGreater.next
        greater.next = None
        return dummySmaller.next

87. 扰乱字符串-Hard

class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
        if len(s1) != len(s2):
            return False
        if s1 == s2:
            return True
        if sorted(s1) != sorted(s2):
            return False

        for i in range(1, len(s1)):
            if self.isScramble(s1[:i], s2[:i]) and self.isScramble(s1[i:], s2[i:]) or \
                    (self.isScramble(s1[:i], s2[-i:]) and self.isScramble(s1[i:], s2[:-i])):
                return True
        return False

或

class Solution:
    def isScramble(self, s1: str, s2: str) -> bool:
        n = len(s1)
        dp = [[[False]*(n+1) for _ in range(n)] for _ in range(n)]
        for i in range(n):
            for j in range(n):
                dp[i][j][1] = s1[i]==s2[j]
        for l in range(2, n+1):
            for i in range(n-l+1):
                for j in range(n-l+1):
                    for k in range(1, l):
                        if dp[i][j][k] and dp[i+k][j+k][l-k] or \
                            dp[i][j+l-k][k] and dp[i+k][j][l-k]:
                            dp[i][j][l] = True
                            break
        return dp[0][0][n]

88. 合并两个有序数组-Easy

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        while m > 0 and n > 0:
            # 从后往前判断，找到nums1和nums2中最大的数放在末尾
            if nums1[m-1] < nums2[n-1]:
                nums1[m-1+n] = nums2[n-1]
                # 已经放入一个数字，因此减少一位
                n = n -1
            else:
                # 如果最大数在nums1中已经排好序，与最后一个位置元素交换
                nums1[m-1+n], nums1[m-1] = nums1[m-1], nums1[m-n+1]
                m = m - 1
        # 插入后，将nums1中的0使用nums2剩下的元素替换
        if m == 0 and n > 0:
            nums1[:n] = nums2[:n]
        return nums1

89. 格雷编码-Medium

class Solution:
    def grayCode(self, n: int) -> List[int]:
        if(n==0):return [0]
        l=[0,1]
        t=2
        h=1
        while(h<n):
            e=l[::-1]
            for i in e:
                l.append(i+t)
            t=t*2
            h=h+1
        return l

90. 子集 II-Medium

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = [[]]
        for i in nums:
            cr = []
            for j in res:
                if j + [i] not in res:
                    cr += [j + [i]]
            res += cr          
        return res

或

class Solution:
    def subsetsWithDup(self, nums: 'List[int]') -> 'List[List[int]]':
        nums.sort()
        res = []
        self.dfs(nums,0,[],res)
        return res
    
    def dfs(self,nums,k,path,res):
        res.append(path)
        for i in range(k,len(nums)):
            if i > k and nums[i] == nums[i-1]:continue
            self.dfs(nums,i+1,path+[nums[i]],res)

91. 解码方法-Medium

class Solution:
    def numDecodings(self, s: str) -> int:
        from functools import lru_cache
        # 存储之前找到的结果到内存中，减少计算
        @lru_cache(None)
        def helper(n):
            if n == 0:
                return 1
            ans = 0
            if n >= 1 and s[n-1] != '0':
                ans += helper(n-1)
            if n >= 2 and 10 <= int(s[n-2:n]) <= 26:
                ans += helper(n-2)
            return ans
        return helper(len(s))

或

def numDecodings(self, s):
        dp = [-1 for i in range(len(s)+1)]
        dp[0] = 1
        def helper(n):
            if dp[n] != -1:
                return dp[n]
            ans = 0
            if n >= 1 and s[n-1] != '0':
                ans += helper(n-1)
            if n >= 2 and 10 <= int(s[n-2:n]) <= 26:
                ans += helper(n-2)
            dp[n] = ans
            return ans
        return helper(len(s))

或

    def numDecodings(self, s):
        n = len(s)
        if n == 1:
            return 1 if s[0] != '0' else 0
        prev2 = 1
        prev1 = 1 if s[0] != '0' else 0
        for i in range(2, len(s) + 1):
            cur = 0
            if s[i-1] != '0':
                cur += prev1
            if 10 <= int(s[i-2:i]) <= 26:
                cur += prev2
            prev2 = prev1
            prev1 = cur 
        return prev1

92. 反转链表 II-Medium

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseBetween(self, head: ListNode, left: int, right: int) -> ListNode:
        dummy = ListNode(0)
        dummy.next = head

        before = dummy
        m = left
        n = right
        for i in range(0, m - 1):
            before = before.next
        
        start = before.next
        then = start.next

        for i in range(0, n - m):
            start.next = then.next
            then.next = before.next
            before.next = then
            then = start.next
        return dummy.next

93. 复原 IP 地址-Medium

class Solution:
    def restoreIpAddresses(self, s: str) -> List[str]:
        res = []
        def backtrace(cnt = 0, ip = '', s = ''):
            if cnt == 4:
                if s == '':
                    res.append(ip[:-1])
                return 
            if len(s) > 0:
                backtrace(cnt + 1, ip + s[0] + '.', s[1:])
            if len(s) > 1 and s[0] != '0':
                backtrace(cnt + 1, ip + s[:2] + '.', s[2:])
            if len(s) > 2 and s[0] != '0' and int(s[0:3]) < 256:
                backtrace(cnt + 1, ip + s[:3] + '.', s[3:])

        backtrace(0, '', s)        
        return res

94. 二叉树的中序遍历-Medium

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def helper(root):
            if not root:
                return
            helper(root.left)
            res.append(root.val)
            helper(root.right)
        helper(root)
        return res

或

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        stack = []
        cur = root
        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left
            cur = stack.pop()
            res.append(cur.val)
            cur = cur.right
        return res

95. 不同的二叉搜索树 II-Medium

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def generateTrees(self, n: int) -> List[TreeNode]:
        if n == 0:
            return []
        return self.helper(1, n)


    def helper(self, start, end):
        if start > end:
            return [None]
        res = []
        # 任取一个root作为该树的root
        for cur_root in range(start, end + 1):
            # 获取左右树的结构
            left = self.helper(start, cur_root - 1)
            right = self.helper(cur_root + 1, end)
            # 对所有可能的树进行组合
            for l in left:
                for r in right:
                    root = TreeNode(cur_root)
                    root.left = l
                    root.right = r
                    res.append(root)
        return res

96. 不同的二叉搜索树-Medium

class Solution:
    def numTrees(self, n: int) -> int:
        # numTrees[4] = numTrees[0] * numTrees[3]+
        #               numTrees[3] * numTrees[0]+
        #               numTrees[1] * numTrees[2]+
        #               numTrees[2] * numTrees[1]
        numTree = [1] * (n + 1)
        for nodes in range(2, n + 1):
            total = 0
            for root in range(1, nodes + 1):
                left = root - 1
                right = nodes - root
                total += numTree[left] * numTree[right]
            numTree[nodes] = total
        return numTree[n]

97. 交错字符串-Medium

class Solution:
    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
        n1 = len(s1)
        n2 = len(s2)
        n = len(s3)
        if n1+n2 != n:
            return False
        # dp(i,j)表示是s1的前i个字符和s2的前j个字符能否交错成s3的前i+j个字符
        # 因此答案为dp(n1,n2)
        dp = [[False for _ in range(n2+1)] for _ in range(n1+1)]
        dp[0][0] = True
        # 初始化dp[0][i]和dp[i][0]
        for i in range(1,n1+1):
            dp[i][0] = dp[i-1][0] and (s1[i-1] == s3[i-1])
        for i in range(1,n2+1):
            dp[0][i] = dp[0][i-1] and (s2[i-1] == s3[i-1])
        # 填写dp
        for i in range(1,n1+1):
            for j in range(1,n2+1):
                dp[i][j] = (dp[i-1][j] and s1[i-1] == s3[i+j-1]) or (dp[i][j-1] and 
                s2[j-1] == s3[i+j-1])
        return dp[n1][n2]

98. 验证二叉搜索树-Medium

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        return self.valid(root, float('-inf'), float('inf'))


    def valid(self, root, min, max):
        if not root:
            return True
        if root.val >= max or root.val <= min: return False
        return self.valid(root.left, min, root.val) and self.valid(root.right, root.val, max)

99. 恢复二叉搜索树-Hard

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def recoverTree(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        self.fnode = None
        self.snode = None
        self.preNode = TreeNode(float("-inf"))

        def order(root):
            if not root:
                return 
            order(root.left)
            if self.snode == None and self.preNode.val >= root.val:
                self.fnode = self.preNode
            if self.fnode and self.preNode.val >= root.val:
                self.snode = root
            self.preNode = root
            order(root.right)

        order(root)
        self.fnode.val , self.snode.val = self.snode.val , self.fnode.val

或

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def recoverTree(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        fnode = None
        snode = None
        pre = TreeNode(float("-inf"))

        stack = []
        p = root
        while p or stack:
            while p:
                stack.append(p)
                p = p.left
            p = stack.pop()
            if not fnode and pre.val > p.val: #这是存在异常的情况
                fnode = pre  #找到第一个位置的异常点
            if fnode and pre.val > p.val:
                snode = p  #找到第二个位置的异常点，因为题意说了，只有两个异常，所以无论两者是否挨在一起，只要交换过来值，就一定是对的，此代码不具有泛化性
            
            pre = p
            p = p.right
        fnode.val,snode.val = snode.val,fnode.val

100. 相同的树-Easy

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p is None and q is None:
            return True
        if p is not None and q is not None:
            return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
        return False
吃一口桃酥
关注
LeetCode刷题记录---腾讯精选练习 50 题
weixin_43646592的博客
10-30 624
😄今天是2022年10月30号，我开始了LeetCode的《腾讯精选练习 50 题》专题 刷题！
LeetCode刷题记录---程序员面试金典(第 6 版)
weixin_43646592的博客
03-25 533
LeetCode刷题记录---程序员面试金典(第 6 版)
Python二维列表排序之lambda,sorted,filter,map函数
IT OR 考公？
11-26 5303
List2 = sorted(list2,key = lambda x:x[0],reverse = False)#按列表第一个元素的值从小到大输出 L2 = list(map(lambda x:x**2,L))#map()返还列表元素计算结果 L3 = filter(lambda x:(x%2 == 1),L)#filter()筛选符合lambda表达式的列表元素
sort(key = lambda x:(sum(x[1:],x[0])),reverse = True)详解
最新发布
weixin_51504215的博客
04-05 1320
sort的高级用法
二级计算机考试（python)中经常遇到 ls.sort(key=lambda x:x[1] , reverse=True),详细解析
weixin_45226820的博客
02-26 2万+
ls.sort(key=lambda x:x[1] , reverse=True)
python sort和sorted函数
weixin_33794672的博客
08-13 1363
sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。 sorted 语法： sorted(iterable[, cmp[, key[, reverse]...
Python 函数 sort()，sorted() 之区别及 key=lambda x:x[] 之理解
热门推荐
iprobobo的博客
01-28 2万+
数据排序
LeetCode刷题记录---拓扑排序（Topological Order）算法
weixin_43646592的博客
08-07 678
这里先来讲下拓扑排序：  一个较大的工程经常被分成许多子工程，把这些子工程称为活动。可用有向图来反映出各个活动之间的先后顺序。顶点代表活动，有向边代表活动的先后顺序。通常称这种图为顶点活动网（AOV）。一个AOV网是一个有向无环图（所以判断是否存在拓扑序列，即判断该有向图是不是无环图）。  在AOV网中，把所有活动排列成一个线性序列，使得每个活动的所有前驱活动都排在该活动的前面，把此序列叫做拓扑序列，由AOV网构造拓扑序列的过程就叫拓扑排序。  拓扑序列不唯一。  拓扑排序算法主要是循环执行两步，直到不存在
leetcode卡-leetcode_python_and_[removed]记录一下leetcode刷题记录,来督促一下自己
07-06
【描述】部分说明了这个资源的用途——记录作者在LeetCode上的刷题历程，作为一种自我监督和学习的方法。"争取可以每天打卡"意味着作者试图每天都参与解题，以此保持持续的学习状态。 【标签】"系统开源"可能意味着...
谷歌师兄的leetcode刷题笔记-jarvis:Jarvis是一个用Python编写的简单帮助程序
06-30
谷歌师兄的leetcode刷题笔记贾维斯 一个用 Python 编写的简单 Jarvis。 还有很多工作要做 节点 Jarvis 由一系列节点组成，如下所示。 想象 声音 输入：wave 文件 ID 播放波形文件。 文字转语音 在：文本字符串 使用 ...
for j,k in sorted(values.items(),key=lambda x:x[1],reverse = True)[:10]: 代码分析
cuicui_ruirui的博客
03-02 2526
这句代码来源于实验楼的一个实验，python破解验证码，此处贴出相关部分代码，以便解释 his = im.histogram() values = {} for i in range(256): values[i] = his[i]#添加字典元素方法：以下标作为键来添加元素 for j,k in sorted(values.items(),key=lambda x:x[1],rev...
python基础：l.sort(key=lambda s: s[1], reverse=True)
weixin_39266845的博客
07-12 3491
python基础题：l.sort(key=lambda s: s[1], reverse=True)
python二级大题—1-12
qq_46188169的博客
03-20 342
【代码】python二级大题
递归及应用（汉诺塔问题）、列表查找、列表排序
weixin_43384009的博客
05-21 492
@TOC 1、 递归 递归的两个特点：调用自身和结束条件 fun3和fun4的打印顺序不同 2、汉诺塔问题 n=2时的移动步骤： n个盘子时：将三个盘子从a移动到c def hanoi(n, a, b, c): """ :param n: 表示n个盘子 :param a: 表示从那个柱子移动 :param b: 表示经过那个柱子 :param c: 表示到那个柱子 :return: """ if n > 0: h
python 二级 真题 list，sort，lambda模块
yk 坤帝
03-02 3200
python 二级 真题 list，sort，lambda模块 list.sort(key=lambda x:x[1],reverse = True) 首先说一下 sort函数 sort函数是一个专门对列表进行排序的一个函数，下面是官方的解释 我的理解是，按照列表维度（指数组中第0，1，2个元素）进行排序，默认为从小到大，'reverse=True’则意味着从大到小。 关于维度，形象地理解如下: list = [('i','he',5), ('q', 'I', 3), ('p', 'they', 1)]
【计算机二级Python】模拟试卷第6套选择题
BetterBench的博客
01-08 8929
第六套 1. 算法的时间复杂度是指 A、执行算法程序所需要的时间 B、算法程序的长度 C、算法程序中的指令条数 D、算法执行过程中所需要的基本运算次数 正确答案： D 2. 下列关于栈的叙述中正确的是 A 在栈中只能插入数据 B 在栈中只能删除数据 C 栈是先进先出的线性表 D 栈是先进后出的线性表 正确答案： D 3. 对建立良好的程序设计风格，下面描述正确的是 A 符号名的命名只要符合语法 B 充分考虑程序的执行效率 C 程序的注释可有可无 D程序应简单、清晰、可读性好 正确答案： D 4. 在面向对象
python递归函数例题_递归讲解及其python实现例题(leetcode)
weixin_39639622的博客
11-23 515
递归递归是一种自己调用自己的编程方式，递归的一个最大的特点是: 将大型复杂的问题转化为较小的与原始问题类似的问题。递归的代码设计简单明了。它包含的三个条件是: 1. 边界条件，2. 递归前进段， 3. 递归返回段设计递归程序一般包含下面两个: 1.设计递归式， 2. 给定终止条件我们将使用leetcode中的例题进行记录学习二叉树的最大深度我们知道二叉树只包含左右孩子两个节点，并且节点的数值可以为...
# 60. 排列序列
Haku_yyf的博客
11-22 121
暴力解法: class Solution: def getPermutation(self, n: int, k: int) -> str: nums = [str(i+1) for i in range(n)] if(len(nums) == 0): return "" tmp = [] res = [] flag = [0] * len(nums) def back.
垃圾小白羊的leetcode刷题记录6
cmaster1219的博客
07-12 224
我的解法： class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: if not matrix: return [] if len(matrix)==1: return matrix[0] m,n = len(matrix),len(matrix[0]) directions = [(.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值