qqMiSa的博客

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。注意：如果 s 中存在这样的子串，我们保证它是唯一的答案。一刷：class Solution: def minWindow(self, s: str, t: str) -> str: tmap = collections.defaultdict(int) for i in t:

题目：给你两个单词word1 和word2，请你计算出将word1转换成word2 所使用的最少操作数。你可以对一个单词进行三种操作：插入一个字符，删除一个字符，替换一个字符。动态规划标准步骤：1. 找转移状态...

题目：给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。解法：1.单调栈思想，维护一个单调不增的数组的下标i~k，当出现一个比单调栈顶更大的元素num，则出栈后j~k的元素的最近更大元素即为num2.注意是循环数组，单调栈最后剩下的下标要继续与开头的n位数组相比较, 可以将原数组拉直（扩展遍历两次），进行

要求用O(n)的时间复杂度进行查找：1. 申请额外空间n个空间，记录当前数字是否出现过def find1(a, n): res = [] b = [0 for x in range(n)] for i in a: b[i-1] = 1 for i in range(n): if b[i] == 0: res.append(i+1) return res2.利用数学公式，先求1到n的平方和和1到.

I、&和and、or在逻辑运算的区别a,b 都是布尔型时，|、&和and、or用法几乎一致但是需要注意的是：and、or也称作短路操作符或者惰性求值，它们的参数从左向右解析，一旦结果可以确定就停止。例如 a = True, b = False, c = Truea or b or c 不会解析b和ca | b | c 则a、b、c都会解析def a(): print("a") return Truedef b(): print("b.

简单部分数组中重复的数字： hash表、数组遍历在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。示例：输入：[2, 3, 1, 0, 2, 5, 3]输出：2 或 3 PS: 2 <= n <= 100000一刷：遍历数组再用hash表存放：class Solution: def findRepeatNumber

给定正整数数组A，A[i]表示第 i 个观光景点的评分，并且两个景点i 和j之间的距离为j - i。一对景点（i < j）组成的观光组合的得分为（A[i] + A[j] + i- j）：景点的评分之和减去它们两者之间的距离。返回一对观光景点能取得的最高分。PS：2 <= A.length <= 50000 1 <= A[i] <= 1000题目一看，暴力解法O()，那么题目肯定是要我们进行优化的如何优化，hash、动态规划啥的都用不上，再仔...

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。class Solution: def longestCommonPrefix(self, strs: List[str]) -> str: if strs == []: return "" # 初始最长公共前缀为数组中第一个元素 result = strs[0] for i in range(1, len(st.

类似于：柱状图中最大的矩形(单调栈*)请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。PS:你能不将整数转为字符串来解决这个问题吗？一刷：时间复杂度O(logn)，空间复杂度O(1)，但是这个解法最少循环1次最多循环1.5次,可以进行优化class Solution: def isPalindrome(self, x: int) -> bool: if x < 0: return False i = 1

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。动态规划可以类比这道题，节省空间还借用了这道题的思想class Solution: def translateNum(self, num: int) -> int: quotient, remainder = divmod(num,10)

对于非负整数X而言，X的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果X = 1231，那么其数组形式为[1,2,3,1]。给定非负整数 X 的数组形式A，返回整数X+K的数组形式。PS：1 <= A.length <= 100000 <= A[i] <= 90 <= K <= 10000如果A.length > 1，那么A[0] != 0class Solution: def addToArrayFor...

给定一个未排序的整数数组，找出最长连续序列的长度。要求算法的时间复杂度为O(n)。一刷:暴力解法的话很简单的想到需要两层循环，时间复杂度为O(n)，这里可以利用hash表来存放原数组，将每次循环数组后的遍历操作变为hash索引操作，就可以将原本判断需要O(n)的时间降为O(1)class Solution: def longestConsecutive(self, nums: List[int]) -> int: nums_hash = set(nums).

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。ps:0 <= matrix.length <= 100 0 <= matrix[i].length<= 100螺旋打印数组，可以围着打印一圈，注意循环条件class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: if not matrix or not matrix[0]:..

给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。ps:题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内。说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。进阶：你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）获得当前数组的左右乘积，来将其相乘即

爱丽丝参与一个大致基于纸牌游戏 “21点” 规则的游戏，描述如下：爱丽丝以 0 分开始，并在她的得分少于 K 分时抽取数字。 抽取时，她从 [1, W] 的范围中随机获得一个整数作为分数进行累计，其中 W 是整数。 每次抽取都是独立的，其结果具有相同的概率。当爱丽丝获得不少于 K 分时，她就停止抽取数字。 爱丽丝的分数不超过 N 的概率是多少？PS：1. 0 <= K <= N <= 100002. 1 <= W <= 100003. 如果答案与正确答案的误

求1+2+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。ps:1 <= n<= 10000才看到有点懵，什么都不用怎么求，只剩下逻辑运算，位运算，以及加减法，那么只能在剩下的运算找方法。递归：利用逻辑运算短路效应，用逻辑运算代替判断递归的出口class Solution: def __init__(self): self.result = 0 def ...

给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。class Solution: def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]

给定一个二叉树，检查它是否是镜像对称的。一刷:递归：class Solution: def isSymmetric(self, root: TreeNode) -> bool: if root==None: return True def check(left: TreeNode, right:TreeNode) -> bool: if left==None and right==None:

给定n个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。求在该柱状图中，能够勾勒出来的矩形的最大面积。利用暴力查找固定高和宽，时间复杂度都是O()这里用到一个新的思路，单调栈（单调递增栈）：1.如果新的元素比栈顶元素大，就入栈2.如果新的元素较小， 那就一直把栈顶元素 弹出来，直到栈顶比新元素小按照这个规则那么栈内元素会有比较明显的特点:1. 栈内的元素是递增的2. 当元素出栈时， 说明这个新元素是出栈元素向后找第一个比其小的元素3. 当元..

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。一刷：用一个数组来存放前i个房屋最多能偷盗的金额，只要单独考虑第1，2和大于2的情况class Solution: def rob(self, nums: List[int]) -> in

给定一个经过编码的字符串，返回它解码后的字符串。编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。递归：class Solution: def decodeString(self,

给定一个整数数组 A，返回其中元素之和可被 K整除的（连续、非空）子数组的数目。PS:1 <= A.length <= 30000 -10000 <= A[i] <= 10000 2 <= K <= 10000一刷：想到用前缀和，时间复杂度为O()再利用hash优化前缀和，注意：（同余定理）给定一个正整数m，如果两个整数a和b满足a-b能够被m整除，即(a-b)/m得到一个整数，那么就称整数a与b对模m同余，记作a≡b(mod m)。跟之前这个.

给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。PS:不能更改原数组（假设数组是只读的）。只能使用额外的 O(1) 的空间。时间复杂度小于 O() 。数组中只有一个重复的数字，但它可能不止重复出现一次。二分法（统计小于二分查找字符的次数）：class Solution: def findDuplicate(self, nums: List[int])

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。两种操作的时间复杂度要求为O(.

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。你可以假设 nums1 和 nums2 不会同时为空。一刷:class Solution: def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float: def find(k):

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。PS:如果 S 中不存这样的子串，则返回空字符串 ""。 如果 S 中存在这样的子串，我们保证它是唯一的答案。一刷：滑动窗口，滑动后判断是否包含所有字符即可class Solution: def minWindow(self, s: str, t: str) -> str: tmap = collections.defaultdict(int) for

根据一棵树的前序遍历与中序遍历构造二叉树。ps:你可以假设树中没有重复的元素。一刷:递归，比较简明的思路，找到中序中的根节点，划分左右子树就可以了。class Solution: def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode: if preorder == [] or inorder == []: return None

题目：给定一个字符串 s，找到 s 中最长的回文子串。你可以假设s 的最大长度为 1000。一刷：一刷只想到中心扩展，只有1个或者两个字母组成中心class Solution: def expand(self, s: str, left: int, right: int): while(left >= 0 and right < len(s) and s[left] == s[right]): left -= 1 .

题目：给你一个字符串s，请你返回满足以下条件的最长子字符串的长度：每个元音字母，即'a'，'e'，'i'，'o'，'u' ，在子字符串中都恰好出现了偶数次。PS：1 <= s.length <= 5 x 10^5 s只包含小写英文字母。一刷：显然这种判断中间位置的就要考虑前缀和的思想class Solution: def findTheLongestSubstring(self, s: str) -> int: ans, status =...

题目：给定一个非空字符串s，最多删除一个字符。判断是否能成为回文字符串。PS：字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。一刷：利用左边右边不等就往前进一位在进行判断class Solution: def validPalindrome(self, s: str) -> bool: print(s[::-1]) flag = 0 l = len(s) left = 0 ri.

题目：给你一个整数数组 nums，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。一刷:class Solution: def maxProduct(self, nums: List[int]) -> int: max_, min_, ans = nums[0], nums[0], nums[0] for i in range(1, len(nums)): tmp_max, .

题目：现在你总共有 n 门课需要选，记为 0 到 n-1。在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。PS:输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。 你可以假定输入的先决条件中没有重复的边。这个问题相当于查找一个循环是否存在于有

题目：给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。PS:你的算法只能使用常数的额外空间。 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。一刷：class Solution: def reverse(self, head: ListNode, tail: ListNode) -> ListNode: p =

给定一个整数数组和一个整数k，你需要找到该数组中和为k的连续的子数组的个数。ps：数组的长度为 [1, 20,000]。 数组中元素的范围是 [-1000, 1000] ，且整数k的范围是[-1e7, 1e7]一刷：直接暴力，那么时间是O()，跑不了前缀和：从0项到当前项的总和那么第i到第j的和就是第j的前缀和减去第i的前缀和class Solution: def subarraySum(self, nums: List[int], k: int) -&g...

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。ps:你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？一刷：想到用hash存放数以及出现的次数，但是空间复杂度是O(n)这里只能用位运算来解决异或算法，一个数与它本身的异或运算为0，与0的异或运算都为它本身，且运算满足交换律和结合律那么做一个累乘就OK了class Solution: def singleNumber(self, nums: List

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。一刷：直接用一个数组存放返回值，一个数组存放当前节点值class Solution: def levelOrder(self, root: TreeNode) -> List[List[int]]: if root == None: return [] node_list = [root] out_list = [[r

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 1. push(x) —— 将元素 x 推入栈中。 2. pop() —— 删除栈顶的元素。 3. top() —— 获取栈顶元素。 4. getMin() —— 检索栈中的最小元素。PS：pop、top 和 getMin 操作总是在 非空栈 上调用。一刷：...

实现pow(x, n)，即计算 x 的 n 次幂函数。一开始没注意条件-100.0 <x< 100.0 n是 32 位有符号整数，其数值范围是[−231,231− 1]很自然的想到for循环相乘，果不其然超时了，核心思想应该是求2的11次方，即求2^2->2^5->2^11一刷：分治法：class Solution: def myPow(self, x: float, n: int) -> float: def...

题目：给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”PS:所有节点的值都是唯一的。 p、q 为不同节点且均存在于给定的二叉树中。一刷：递归class Solution: def lowestCommonAncestor(self, root: 'TreeNode', p: 'Tr