数据艺术家

支持向量机的类别划分：用于解决二类分类问题的监督学习模型非概率模型线性模型&非线性模型：线性支持向量机是线性模型，核函数支持向量机是非线性模型。非参数化模型判别模型【补充说明】合页损失函数在P. 131有详细讲解。希尔伯特空间希尔伯特空间，即完备正交的线性空间。“完备”是指状态的所有可能值都被这个空间包含了。例如有理数集就是不完备的。“正交”是指各个坐标基相互垂直/正交。“线性”是指不同的量之间满足加法规则。希尔伯特空间可以是无穷维，也可以是有限维。7.1.1 线性可分支持向

【补充说明】原始问题和对偶问题的简单理解如下：原始问题：在确定 xxx 的情况下，求使 L(x,α,β)L(x,\alpha,\beta)L(x,α,β) 取得最大值的 α\alphaα 或 β\betaβ；然后在所有求出来的 L(x,α,β)L(x,\alpha,\beta)L(x,α,β) 的最大值中，寻找取值最小值时的 xxx。对偶问题：在确定 α\alphaα 和 β\betaβ 的情况下，求使 L(x,α,β)L(x,\alpha,\beta)L(x,α,β) 取得最小值的 xxx；然后在所

《统计学习方法》啃书辅助：附录B 牛顿法和拟牛顿法B.1 牛顿法【基础知识】梯度【基础知识】浅谈「正定矩阵」和「半正定矩阵」 - Xinyu Chen 的文章 - 知乎二阶泰勒展开和黑塞矩阵若一元函数 f(x)f(x)f(x) 具有二阶连续导数，则 f(x)f(x)f(x) 在点 x0x_0x0​ 处的二阶泰勒展开式如下（省略高阶无穷小）：f(x)=f(x0)+f′(x0)Δx+12f′′(x0)(Δx)2f(x) = f(x_0) + f'(x_0) \Delta x + \frac{1}{

【补充说明】书中没有区分“梯度下降法”和“最速下降法”，但实际上两者是存在区别的。算法A.1的梯度下降法实际上是最速下降法。梯度下降法和最速下降法在确定步长时，我们有两种思路：一种是依据瞬时变化率计算步长，在距离极值点较远时，步长取得更大一些，使算法收敛更快；而当距离极值点较近时，步长取得更小一些，避免在极小值点产生震荡；另一种是依据一维搜索计算步长，即在每次确定迭代方向后，直接移动到当前方向的极值点（驻点），从而避免在当前方向上的反复震荡。第一种依据瞬时变化率计算步长的方法，就是梯度下降法；第二种依

逻辑斯谛回归模型的学习过程：通过求解对数似然函数极大化，得到条件概率分布 P(Y∣X)P(Y|X)P(Y∣X)。逻辑斯谛回归模型的预测过程：直接使用模型的条件概率分布 P(Y∣X)P(Y|X)P(Y∣X) 进行预测。逻辑斯谛回归模型的类别划分：用于解决分类问题的监督学习模型概率模型&非概率模型：既可以看作是概率模型，也可以看作是非概率模型参数化模型：假设模型参数的维度固定判别模型：由数据直接学习决策函数 f(Y∣X)f(Y|X)f(Y∣X)逻辑斯谛回归模型的主要优点：直接对分类进行

决策树的学习过程：利用训练数据，根据损失函数最小化的原则建立决策树模型。学习通常包括特征选择、决策树的生成、决策树的修剪三个步骤。决策树的预测过程：对新的数据，利用决策树模型进行分类。决策树的类别划分：用于解决分类和回归问题的监督学习模型概率模型：模型取条件概率分布形式 P(y∣x)P(y|x)P(y∣x)非参数化模型：假设模型参数的维度不固定判别模型：由数据直接学习决策函数 f(X)f(X)f(X)决策树的主要优点：模型具有可读性，分类速度快。决策树的主要缺点：【扩展阅读】skle

朴素贝叶斯法对数据的要求：数据满足特征条件独立假设，即用于分类的特征在类确定的条件下都是条件独立的。朴素贝叶斯法的学习过程：基于特征条件独立假设学习输入输出的联合概率分布。即通过先验概率分布 P(Y=ck)P(Y=c_k)P(Y=ck​) 和条件概率分布 P(X(j)=x(j)∣Y=ck)P(X^{(j)}=x^{(j)}|Y=c_k)P(X(j)=x(j)∣Y=ck​) 实现对联合概率分布 P(X,Y)P(X,Y)P(X,Y) 的估计。朴素贝叶斯法的预测过程：基于模型，对给定的输入 x，利用贝叶斯定理

k 近邻法的学习过程：没有显示的学习过程。k 近邻法（用于分类）的预测过程：在训练数据集中找到与新的输入实例最邻近的 k 个实例，这 k 个实例的多数属于某个类，就把该输入实例分为这个类。k 近邻法的类别划分：用于解决分类或回归问题的监督学习模型非概率模型：模型取函数形式线性模型：模型函数为线性函数非参数化模型：假设模型参数的维度不固定判别模型：由数据直接学习决策函数 f(X)f(X)f(X)k 近邻法的主要优点：精度高、对异常值不敏感、无数据输入假定。k 近邻法的主要缺点：计算复杂度

感知机模型对数据的要求：训练数据集中需存在某个超平面能够将数据集的正实例点和负实例点完全正确地划分到超平面的两侧，即训练数据集是线性可分的。因为只有当训练数据集是线性可分时，感知机学习算法才是收敛的；如果训练数据集线性不可分，则感知机学习算法不收敛，迭代结果会发生震荡。当训练数据集线性不可分时，可以使用线性支持向量机。感知机模型的学习过程：依据训练数据集求得感知机模型，即求得模型参数 www 和 bbb。感知机模型的预测过程：通过学习得到的感知机模型，计算新的输入实例所对应的输出类别。感知机模型的类别

题目：原题链接（中等）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(1)O(1)O(1)488ms (69.57%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maxSumAfterOperation(self, nums: List[int]) -> int: ans = 0 #

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NK)O(NK)O(NK)O(NK)O(NK)O(NK)3620ms (57.89%)Ans 2 (Python)Ans 3 (Python)解法一：MOD = 10 ** 9 + 7class Solution: def waysToDistribute(self, n: int, k: int) -> int:

题目：原题链接（困难）标签：动态规划、字符串解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2)O(N^2)O(N2)O(N2)O(N^2)O(N2)1592ms (84.62%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minimumMoves(self, arr: List[int]) -> int: return self.so

题目：原题链接（中等）标签：动态规划、数组解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(M2×N)O(M^2×N)O(M2×N)O(1)O(1)O(1)3056ms (8.70%)Ans 2 (Python)Ans 3 (Python)解法一（暴力解法）：class Solution: def countCornerRectangles(self, grid: List[List[int]]) -> int:

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NK)O(NK)O(NK)O(N)O(N)O(N)100ms (94.12%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def cheapestJump(self, nums: List[int], k: int) -> List[int]: size = le

题目：原题链接（中等）标签：动态规划、字符串解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(26×N2)O(26×N^2)O(26×N2)O(26×N2)O(26×N^2)O(26×N2)4752ms (38.46%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def longestPalindromeSubseq(self, s: str) -> int:

题目：原题链接（困难）标签：动态规划、字符串解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2)O(N^2)O(N2)O(N2)O(N^2)O(N2)324ms (53.85%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def isValidPalindrome(self, s: str, k: int) -> bool: size = le

题目：原题链接（中等）标签：字符串、哈希表解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2)O(N^2)O(N2)O(N)O(N)O(N)48ms (75.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def beforeAndAfterPuzzles(self, phrases: List[str]) -> List[str]: in

题目：原题链接（中等）标签：二分查找、字符串解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2logN)O(N^2logN)O(N2logN)O(1)O(1)O(1)56ms (55.70%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def longestRepeatingSubstring(self, s: str) -> int: siz

题目：原题链接（中等）标签：字符串、贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(24+60)O(24+60)O(24+60)O(1)O(1)O(1)40ms (65.45%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def nextClosestTime(self, time: str) -> str: hour1, minute1

题目：原题链接（困难）标签：动态规划、数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2)O(N^2)O(N2)O(N)O(N)O(N)324ms (92.00%)Ans 2 (Python)Ans 3 (Python)解法一：MOD = 10 ** 9 + 7class Solution: def numberOfWays(self, num_people: int) -> int:

题目：原题链接（困难）标签：数学、堆、动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)60ms (50.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minBuildTime(self, blocks: List[int], split: int) -> int:

题目：原题链接（中等）标签：动态规划、数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NT)O(NT)O(NT)O(NT)O(NT)O(NT)1684ms (23.64%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def probabilityOfHeads(self, prob: List[float], target: int) -> float:

题目：原题链接（困难）标签：数学、动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(logN)O(logN)O(logN)O(1)O(1)O(1)40ms (100.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def digitsCount(self, d: int, low: int, high: int) -> int: ret

题目：原题链接（困难）标签：数学、进制转换解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(logN)O(logN)O(logN)O(1)O(1)O(1)52ms (18.18%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def newInteger(self, n: int) -> int: bit = 0 while pow(

题目：原题链接（中等）标签：贪心算法、哈希表、字符串解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)112ms (93.55%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def countQuadruples(self, s1: str, s2: str) -> int: size1, size2 =

题目：原题链接（中等）标签：贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)104ms (63.46%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def findBuildings(self, heights: List[int]) -> List[int]: ans = []

题目：原题链接（中等）标签：贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(BlogB+WlogW)O(BlogB+WlogW)O(BlogB+WlogW)O(B+W)O(B+W)O(B+W)360ms (8.33%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maxBoxesInWarehouse(self, boxes: List[int], wa

题目：原题链接（中等）标签：贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(BlogB+W)O(BlogB+W)O(BlogB+W)O(B)O(B)O(B)204ms (21.74%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maxBoxesInWarehouse(self, boxes: List[int], warehouse: List[int

题目：原题链接（中等）标签：贪心算法、堆解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)184ms (63.49%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def connectSticks(self, sticks: List[int]) -> int: ans = 0

题目：原题链接（中等）标签：贪心算法、数学、动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)40ms (68.75%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minimizeError(self, prices: List[str], target: int) -> str:

题目：原题链接（中等）标签：贪心算法、动态规划、二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(S+TLogS)O(S+TLogS)O(S+TLogS)O(S)O(S)O(S)44ms (88.14%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def shortestWay(self, source: str, target: str) -> int:

题目：原题链接（中等）标签：动态规划、贪心算法、数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(2N)O(2^N)O(2N)O(2N)O(2^N)O(2N)超出时间限制Ans 2 (Python)-––44ms (61.68%)Ans 3 (Python)解法一（完全暴力）：class Solution: def maxA(self, n: int) -> int: # dp[i] = [当前

题目：原题链接（中等）标签：二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(logN)O(logN)O(logN)O(1)O(1)O(1)236ms (100.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def getIndex(self, reader: 'ArrayReader') -> int: size = reader.

题目：原题链接（困难）标签：二分查找、贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)212ms (95.52%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maximizeSweetness(self, sweetness: List[int], k: int) -> int:

题目：原题链接（中等）标签：二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N+QlogN)O(N+QlogN)O(N+QlogN)O(N)O(N)O(N)1920ms (84.21%)Ans 2 (Python)Ans 3 (Python)解法一：MAX_INT = 10 ** 5class Solution: def shortestDistanceColor(self, colors: List[in

题目：原题链接（中等）标签：二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(logN)O(logN)O(logN)O(1)O(1)O(1)56ms (55.75%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def missingElement(self, nums: List[int], k: int) -> int: size = l

题目：原题链接（中等）标签：二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(logN)O(logN)O(logN)O(1)O(1)O(1)48ms (58.87%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def search(self, reader, target): left, right = 0, 20000 whil

题目：原题链接（中等）标签：哈希表解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N×M×26)O(N×M×26)O(N×M×26)O(N)O(N)O(N)1392ms (7.69%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def differByOne(self, dict: List[str]) -> bool: hashset = se

题目：原题链接（中等）标签：数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)272ms (8.33%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def guessMajority(self, reader: 'ArrayReader') -> int: size = reader.length()

题目：原题链接（中等）标签：树、深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(H)O(H)O(H)64ms (40.63%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def __init__(self): self.ans = 0 def diameter(self, root: 'Node') -&g

题目：原题链接（中等）标签：树、哈希表解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)144ms (90.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def findRoot(self, tree: List['Node']) -> 'Node': maybe = set(tree)

题目：原题链接（中等）标签：链表、栈解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)40ms (94.23%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def printLinkedListInReverse(self, head: 'ImmutableListNode') -> None: stac

题目：原题链接（困难）标签：离线计算解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(QK)O(QK)O(QK)O(QK)O(QK)O(QK)6916ms (27.27%)Ans 2 (Python)Ans 3 (Python)解法一：MOD = 10 ** 9 + 7class Solution: def solve(self, nums: List[int], queries: List[List[int]])

题目：原题链接（中等）标签：二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(T+26×logN)O(T+26×logN)O(T+26×logN)O(1)O(1)O(1)488ms (94.44%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maxFont(self, text: str, w: int, h: int, fonts: List[int]

题目：原题链接（困难）标签：数学、贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(1)O(1)O(1)60ms (100.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def canDivideIntoSubsequences(self, nums: List[int], k: int) -> bool: l

题目：原题链接（困难）标签：二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)704ms (24.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minmaxGasDist(self, stations: List[int], k: int) -> float:

题目：原题链接（简单）标签：数组、贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(1)O(1)O(1)80ms (60.34%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def largestSubarray(self, nums: List[int], k: int) -> List[int]: max_idx

题目：原题链接（中等）标签：数组、二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(1)O(1)O(1)112ms (90.38%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def leftMostColumnWithOne(self, binaryMatrix: 'BinaryMatrix') -> in

题目：原题链接（中等）标签：数组解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(VK)O(VK)O(VK)O(1)O(1)O(1)76ms (92.86%)Ans 2 (Python)Ans 3 (Python)解法一（暴力）：class Solution: def pourWater(self, heights: List[int], v: int, k: int) -> List[int]:

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)356ms (33.33%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def stoneGameVIII(self, stones: List[int]) -> int: size = len(stones)

题目：原题链接（中等）标签：贪心算法、广度优先搜索、扫描线算法、堆解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)1932ms (66.67%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def canReach(self, s: str, minJump: int, maxJump: int) -&

题目：原题链接（中等）标签：二分查找、数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogK)O(NlogK)O(NlogK)O(1)O(1)O(1)2260ms (16.67%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minSpeedOnTime(self, dist: List[int], hour: float) -> int:

题目：原题链接（简单）标签：数组、双指针解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(1)O(1)O(1)44ms (66.67%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def checkZeroOnes(self, s: str) -> bool: size = len(s) max1, max0

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NK2)O(NK^2)O(NK2)O(NK)O(NK)O(NK)超出时间限制Ans 2 (Python)O(NK)O(NK)O(NK)O(NK)O(NK)O(NK)324ms (98.75%)Ans 3 (Python)解法一（记忆化递归）：MOD = 10 ** 9 + 7# 计算可能用到的阶乘列表factorials = [1]fa

题目：原题链接（中等）标签：有序映射、设计、哈希表解法时间复杂度空间复杂度执行用时Ans 1 (Python)构造 = O(NlogN)O(NlogN)O(NlogN) ; 操作 = O(logN)O(logN)O(logN)O(N)O(N)O(N)5896ms (5.00%)Ans 2 (Python)Ans 3 (Python)解法一：class FindSumPairs: def __init__(self, nums1: L

题目：原题链接（中等）标签：贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(1)O(1)O(1)32ms (98.79%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minSwaps(self, s: str) -> int: c0, c1 = s.count("0"), s.count("1")

题目：原题链接（简单）标签：回溯算法、递归解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(2N)O(2^N)O(2N)O(N)O(N)O(N)96ms (5)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def __init__(self): self.ans = 0 self.nums = [] def subsetXORS

题目：原题链接（困难）标签：数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)3224ms (72.47%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: _MOD = 10 ** 9 + 7 def sumOfFlooredPairs(self, nums: List[int]) ->

题目：原题链接（中等）标签：数组、双指针解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N×M)O(N×M)O(N×M)O(N×M)O(N×M)O(N×M)500ms (41.82%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def rotateTheBox(self, box: List[List[str]]) -> List[List[str]]:

题目：原题链接（中等）标签：数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(\sqrt{N})O(N​)O(1)O(1)O(1)260ms (64.85%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def memLeak(self, memory1: int, memory2: int) -> List[int]: now = 1

题目：原题链接（简单）标签：排序、字符串解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)36ms (81.98%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def sortSentence(self, s: str) -> str: words = s.split()

题目：原题链接（困难）标签：动态规划、图解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N×T)O(N×T)O(N×T)O(N)O(N)O(N)1016ms (85.19%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def mostSimilar(self, n: int, roads: List[List[int]], names: List[str], targ

题目：原题链接（困难）标签：哈希表、图解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)40ms (66.67%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def canConvert(self, str1: str, str2: str) -> bool: if str1 == str2:

题目：原题链接（中等）标签：深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)160ms (13.79%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def deleteTreeNodes(self, nodes: int, parent: List[int], value: List[int]) -> in

题目：原题链接（中等）标签：图、拓扑排序解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N+E)O(N+E)O(N+E)O(N+E)O(N+E)O(N+E)88ms (31.87%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minimumSemesters(self, n: int, relations: List[List[int]]) -> int

题目：原题链接（中等）标签：图、有向图、深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)––92ms (10.46%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def leadsToDestination(self, n: int, edges: List[List[int]], source: int, destination: int) -> bo

题目：原题链接（中等）标签：树、深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)164ms (32.47%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def lowestCommonAncestor(self, root: 'TreeNode', nodes: 'List[TreeNode]') -> '

题目：原题链接（中等）标签：树解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)44ms (60.00%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def flipBinaryTree(self, root: 'Node', leaf: 'Node') -> 'Node': if root == lea

题目：原题链接（中等）标签：树、广度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)188ms (95.65%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def correctBinaryTree(self, root: TreeNode) -> TreeNode: visited = {ro

题目：原题链接（中等）标签：树解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)92ms (16.09%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def lowestCommonAncestor(self, p: 'Node', q: 'Node') -> 'Node': lst1 = set()

题目：原题链接（中等）标签：树、深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)316ms (60.19%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -&

题目：原题链接（中等）标签：广度优先搜索、深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)260ms (12.50%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def crawl(self, startUrl: str, htmlParser: 'HtmlParser') -> List[str]:

题目：原题链接（中等）标签：广度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(X×Y)O(X×Y)O(X×Y)O(X×Y)O(X×Y)O(X×Y)6356ms (16.16%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minKnightMoves(self, x: int, y: int) -> int: ans = 0

题目：原题链接（中等）标签：树、二叉树、深度优先搜索、广度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)108ms (47.50%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def findDistance(self, root: TreeNode, p: int, q: int) -> int:

题目：原题链接（中等）标签：广度优先搜索、深度优先搜索、图解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(M×N)O(M×N)O(M×N)O(M×N)O(M×N)O(M×N)276ms (9.80%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def getFood(self, grid: List[List[str]]) -> int: m,

题目：原题链接（困难）标签：贪心算法、哈希表解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)304ms (23.08%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maximumBeauty(self, flowers: List[int]) -> int: count = collection

题目：原题链接（中等）标签：广度优先搜索、深度优先搜索、图解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(M×N)O(M×N)O(M×N)O(M×N)O(M×N)O(M×N)7568ms (32.26%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution(object): # 方向列表 _DIRECTIONS = [(0, 1, "U"), (0, -1, "D"),

题目：原题链接（困难）标签：贪心算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)164ms (25.00%)Ans 2 (Python)Ans 3 (Python)解法一：def next_permutation(nums): """ 将当前排列重新排列为字典序中下一个更大的排列 最大排列（例如[3,2,1]）的下一个排列是最小的排列（例如[1,2,3]）

题目：原题链接（中等）标签：排序、哈希表解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)284ms (18.92%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def sortFeatures(self, features: List[str], responses: List[str]) ->

题目：原题链接（困难）标签：排序、数学解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(L2logL2)O(L^2logL^2)O(L2logL2)O(L2)O(L^2)O(L2)60ms (57.14%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def maximumNumberOfOnes(self, width: int, height: int, length

题目：原题链接（中等）标签：贪心算法、排序解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2logN2)O(N^2logN^2)O(N2logN2)O(N2)O(N^2)O(N2)2120ms (6.06%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def assignBikes(self, workers: List[List[int]], bikes: Lis

题目：原题链接（中等）标签：数组、双指针解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)644ms (33.33%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def findRLEArray(self, encoded1: List[List[int]], encoded2: List[List[int]]) ->

题目：原题链接（困难）标签：数组、二分查找解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogK)O(NlogK)O(NlogK)O(N)O(N)O(N)1756ms (34.48%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def findMaxAverage(self, nums: List[int], k: int) -> float:

题目：原题链接（困难）标签：并查集、图、二进制拆分解法时间复杂度空间复杂度执行用时Ans 1 (Python)构造 = O((N+M)log(N+M))O((N+M)log(N+M))O((N+M)log(N+M)) ; 操作 = O(log(N+M))O(log(N+M))O(log(N+M))O(N+M)O(N+M)O(N+M)1660ms (66.67%)Ans 2 (Python)Ans 3 (Python)解法一：class Dis

题目：原题链接（困难）标签：图、Prim算法、Kruskal算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)184ms (86.67%)Ans 2 (Python)Ans 3 (Python)解法一：import collectionsimport heapqfrom typing import Listclass Solution: d

题目：原题链接（中等）标签：图、Prim算法、Kruskal算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)208ms (62.25%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minimumCost(self, n: int, connections: List[List[int]])

题目：原题链接（中等）标签：广度优先搜索、堆解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(NlogN)O(NlogN)O(NlogN)O(N)O(N)O(N)948ms (100.00%)Ans 2 (Python)Ans 3 (Python)解法一：import heapqclass Solution: def maximumMinimumPath(self, grid: List[List[int]]) -&

题目：原题链接（中等）标签：并查集、排序解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(N)O(N)O(N)48ms (100.00%)Ans 2 (Python)Ans 3 (Python)解法一：class DSU: def __init__(self, n: int): self._n = n self._array = [i for i in range(

题目：原题链接（中等）标签：并查集、深度优先搜索解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N)O(N)O(N)O(26)O(26)O(26)44ms (97.14%)Ans 2 (Python)Ans 3 (Python)解法一：class DSU: def __init__(self, n: int): self._n = n self._array = [i for i in

题目：原题链接（中等）标签：SQL解法时间复杂度空间复杂度执行用时Ans 1 (SQL)––661ms (27.58%)Ans 2 (SQL)Ans 3 (SQL)解法一：SELECT SUM(B.apple_count + IFNULL(C.apple_count, 0)) AS apple_count, SUM(B.orange_count + IFNULL(C.orange_count, 0)) AS orange_cou

题目：原题链接（中等）标签：SQL解法时间复杂度空间复杂度执行用时Ans 1 (SQL)––382ms (34.66%)Ans 2 (SQL)Ans 3 (SQL)解法一：SELECT user_id, MAX(diff) AS biggest_windowFROM (SELECT user_id, DATEDIFF(LEAD(visit_date, 1, '2021-1-1') OVER (PART

题目：原题链接（简单）标签：SQL解法时间复杂度空间复杂度执行用时Ans 1 (SQL)––364ms (43.84%)Ans 2 (SQL)Ans 3 (SQL)解法一：SELECT date_id, make_name, COUNT(DISTINCT lead_id) AS unique_leads, COUNT(DISTINCT partner_id) AS unique_partnersFR

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(M3)O(M^3)O(M3)O(M2)O(M^2)O(M2)908ms (57.63%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def minCost(self, n: int, cuts: List[int]) -> int: # 排序cuts并添加左右端点

题目：原题链接（困难）标签：数学、回溯算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)––2776ms (17.54%)Ans 2 (Python)Ans 3 (Python)解法一：from itertools import productfrom math import factorialfrom math import prodclass Solution: def getProbability(sel

题目：原题链接（困难）标签：动态规划、记忆化递归解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2×M)O(N^2×M)O(N2×M)O(N2×M)O(N^2×M)O(N2×M)604ms (97.40%)Ans 2 (Python)Ans 3 (Python)解法一：import functoolsclass Solution: def cherryPickup(self, grid: List[List[i

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(M×N)O(M×N)O(M×N)O(M×N)O(M×N)O(M×N)336ms (89.39%)Ans 2 (Python)Ans 3 (Python)解法一：MIN_INT = -10 ** 9class Solution: def maxDotProduct(self, nums1: List[int], nums2: Lis

题目：原题链接（困难）标签：深度优先搜索、Tarjan算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N+E)O(N+E)O(N+E)O(N+E)O(N+E)O(N+E)916ms (40.22%)Ans 2 (Python)Ans 3 (Python)解法一：import collectionsfrom typing import Listclass Solution: def criticalConne

题目：原题链接（困难）标签：设计、堆、有序映射解法时间复杂度空间复杂度执行用时Ans 1 (Python)每个操作 = O(logN)O(logN)O(logN)O(N)O(N)O(N)124ms (12.00%)Ans 2 (Python)Ans 3 (Python)解法一：import heapqfrom sortedcontainers import SortedListclass DinnerPlates: def __

题目：原题链接（困难）标签：动态规划、记忆化递归、回溯算法解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(2N×P)O(2^N×P)O(2N×P)O(2N)O(2^N)O(2N)164ms (96.20%)Ans 2 (Python)Ans 3 (Python)解法一：import collectionsimport functoolsfrom copy import copyclass Solution: d

题目：原题链接（困难）标签：动态规划解法时间复杂度空间复杂度执行用时Ans 1 (Python)O(N2)O(N^2)O(N2)O(N2)O(N^2)O(N2)492ms (47.06%)Ans 2 (Python)Ans 3 (Python)解法一：class Solution: def shortestCommonSupersequence(self, str1: str, str2: str) -> str: