tus00000的博客

0 <= i < j < k < n，其中 n = nums.length。由于答案可能非常大，请返回结果对 109 + 7 取余数后的值。此算法时间复杂度为O(n)，空间复杂度为O(n)。此算法时间复杂度为O(n)，空间复杂度为O(n)。输入： nums = [8,4,2,8,4]输入： nums = [0,1,0,0]输入： nums = [6,3,6]返回数组中 特殊三元组 的总数。给你一个整数数组 nums。

请你找出 nums 中 元素和最小 的山形三元组，并返回其 元素和。如果不存在满足条件的三元组，返回 -1。如果nums的大小为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。nums[i] < nums[j] 且 nums[k] < nums[j]给你一个下标从 0 开始的整数数组 nums。输入：nums = [5,4,8,7,10,2]输入：nums = [6,5,4,3,4,5]解释：可以证明 nums 中不存在山形三元组。输入：nums = [8,6,1,5,3]

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]此算法时间复杂度为O(n。)，空间复杂度为O(n。

解释：唯一的下标三元组 (0, 1, 2) 的值是一个负数，(nums[0] - nums[1]) * nums[2] = -3。解释：下标三元组 (1, 2, 4) 的值是 (nums[1] - nums[2]) * nums[4] = 133。解释：下标三元组 (0, 2, 4) 的值是 (nums[0] - nums[2]) * nums[4] = 77。下标三元组 (i, j, k) 的值等于 (nums[i] - nums[j]) * nums[k]。输入：nums = [1,2,3]

如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果 nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和 nums[j] 是一组 美丽下标对。2 和 1 互质，因此 gcd(2,1) == 1。i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1。i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1。

给你一个整数数组 hours，表示以 小时 为单位的时间，返回一个整数，表示满足 i < j 且 hours[i] + hours[j] 构成 整天 的下标对 i, j 的数目。例如，1 天是 24 小时，2 天是 48 小时，3 天是 72 小时，以此类推。构成整天的下标对分别是 (0, 1)、(0, 2) 和 (1, 2)。输入： hours = [12,12,30,24,24]构成整天的下标对分别是 (0, 1) 和 (3, 4)。输入： hours = [72,48,24,3]

形式上，我们希望下标数字 i 和 j 满足 i < j 且有 (time[i] + time[j]) % 60 == 0。用哈希表记录每首歌曲的持续时间对60取余的结果（key）及其数量（value），枚举time，对于其中的每个值i，看哈希表中是否存在以。(time[0] = 30, time[2] = 150): 总持续时间 180。(time[1] = 20, time[3] = 100): 总持续时间 120。(time[1] = 20, time[4] = 40): 总持续时间 60。

nums[j] - nums[i] ，那么我们称 (i, j) 是一个 坏数对。，枚举nums，对于当前枚举的值的下标i，我们把nums[i]-i加入哈希表，然后看后面是否还存在j，使得。数对 (0, 2) 是坏数对，因为 2 - 0!数对 (0, 3) 是坏数对，因为 3 - 0!数对 (1, 2) 是坏数对，因为 2 - 1!数对 (2, 3) 是坏数对，因为 3 - 2!解释：数对 (0, 1) 是坏数对，因为 1 - 0!输入：nums = [1,2,3,4,5]

现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b|。一种得到答案 4 的方法是从第一个数组或者第三个数组中选择 1，同时从第二个数组中选择 5。如果arrays的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。输入：[[1,2,3],[4,5],[1,2,3]]给定 m 个数组，每个数组都已经按照升序排好序了。输入：arrays = [[1],[1]]arrays[i] 以 升序 排序。

剩下的 两个 元素中，一个是所有 特殊数字 的 和 ，另一个是 异常值。我们可以用哈希表保存下来nums中的每个数字及其出现次数，然后对nums求和得到sum，数组中有一个数字是另外n-2个数字的和，将其记为S，那么。特殊数字可以是 1、1、1、1 和 1，因此和为 5，另一个 5 为异常值。特殊数字可以是 -2、-1 和 -3，因此和为 -6，异常值为 4。输入： nums = [-2,-1,-3,-6,4]输入： nums = [1,1,1,1,1,5,5]输入： nums = [2,3,5,10]

如果points中有n个点，点所在的行的范围为m，则此算法时间复杂度为O(n)，空间复杂度为O(m)。输入： points = [[1,0],[2,0],[3,0],[2,2],[3,2]]输入： points = [[0,0],[1,0],[0,1],[2,1]]使用点 [1,0]、[2,0]、[3,2] 和 [2,2]。使用点 [2,0]、[3,0]、[3,2] 和 [2,2]。使用点 [1,0]、[3,0]、[3,2] 和 [2,2]。只有一种方式可以组成一个水平梯形。+ 7 取余数后的值。

如果nums的长度为n，nums中元素的种类数为m，则此算法时间复杂度为O(n)，空间复杂度为O(m)。设计一个算法，找出数组中两数之和为指定值的所有整数对。一个数只能属于一个数对。输入：nums = [5,6,5,6], target = 11。输入：nums = [5,6,5], target = 11。输出：[[5,6],[5,6]]输出：[[5,6]]

如果nums的长度为n，nums中元素的种类数为m，则此算法时间复杂度为O(n)，空间复杂度为O(m)。每一步操作中，你需要从数组中选出和为 k 的两个整数，并将它们移出数组。输入：nums = [3,1,3,4,3], k = 6。输入：nums = [1,2,3,4], k = 5。给你一个整数数组 nums 和一个整数 k。返回你可以对数组执行的最大操作数。

给你一个下标从 0 开始的数组 nums ，数组中的元素都是 正 整数。= j），且 nums[i] 的数位和 与 nums[j] 的数位和相等。请你找出所有满足条件的下标 i 和 j ，找出并返回 nums[i] + nums[j] 可以得到的 最大值。如果nums的长度为n，其中数字的大小为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(n)。输入：nums = [18,43,36,13,7]输入：nums = [10,12,19,14]解释：不存在满足条件的数对，返回 -1。

i = 1 和 j = 2 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 71 + 17 = 88。i = 3 和 j = 4 ，nums[i] 和 nums[j] 数位上最大的数字相等，且这一对的总和 24 + 42 = 66。请你从 nums 中找出和 最大 的一对数，且这两个数数位上最大的数字相等。如果nums的长度为n，其中数字的平均大小为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。输入：nums = [1,2,3,4]

如果两张卡牌的值相同，则认为这一对卡牌 匹配。解释：拿起卡牌 [3,4,2,3] 将会包含一对值为 3 的匹配卡牌。注意，拿起 [4,2,3,4] 也是最优方案。返回你必须拿起的最小连续卡牌数，以使在拿起的卡牌中有一对匹配的卡牌。如果无法得到一对匹配的卡牌，返回 -1。如果cards的长度为n，卡牌的种类数为m，则此算法时间复杂度为O(n)，空间复杂度为O(m)。输入：cards = [3,4,2,3,4,7]解释：无法找出含一对匹配卡牌的一组连续卡牌。输入：cards = [1,0,5,3]

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k。如果存在，返回 true；否则，返回 false。如果nums的长度为n，nums中值的种类为m，则此算法时间复杂度为O(n)，空间复杂度为O(m)。输入：nums = [1,2,3,1,2,3], k = 2。输入：nums = [1,2,3,1], k = 3。输入：nums = [1,0,1,1], k = 1。

给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的 最大差值 ，其中 0 <= i < j < n 且 nums[i] < nums[j]。注意，尽管 i = 1 且 j = 0 时 ，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4。

解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；如果prices的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(1)。解释：在这种情况下, 没有交易完成, 所以最大利润为 0。输入：prices = [7,6,4,3,1]输入：[7,1,5,3,6,4]

形式上，dominoes[i] = [a, b] 与 dominoes[j] = [c, d] 等价 当且仅当 (a == c 且 b == d) 或者 (a == d 且 b == c)。如果dominoes的长度为n，多米诺骨牌对的种类为m，则此算法时间复杂度为O(n)，空间复杂度为O(m)。输入：dominoes = [[1,2],[1,2],[1,1],[1,2],[2,2]]输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]给你一组多米诺骨牌 dominoes。

更规范的说法是，两个矩形满足 widthi/heighti == widthj/heightj（使用实数除法而非整数除法），则认为这两个矩形 可互换。用一个下标从 0 开始的二维整数数组 rectangles 来表示 n 个矩形，其中 rectangles[i] = [widthi, heighti] 表示第 i 个矩形的宽度和高度。输入：rectangles = [[4,8],[3,6],[10,20],[15,30]]输入：rectangles = [[4,5],[7,8]]

给你一个 不包含 任何零的整数数组 nums ，找出自身与对应的负数都在数组中存在的最大正整数 k。如果nums的长度为n，则此算法时间复杂度为O(n)，空间复杂度为O(n)。解释：数组中存在 1 和 7 对应的负数，7 的值更大。返回正整数 k ，如果不存在这样的整数，返回 -1。输入：nums = [-10,8,6,7,-2,-3]输入：nums = [-1,10,6,7,-7,1]解释：不存在满足题目要求的 k ，返回 -1。输入：nums = [-1,2,-3,3]

给定一个长度为 n 的整数 山脉 数组 arr ，其中的值递增到一个 峰值元素 然后递减。如果arr的大小为n，则此算法时间复杂度为O(logn)，空间复杂度为O(1)。你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。输入：arr = [0,10,5,2]题目数据 保证 arr 是一个山脉数组。输入：arr = [0,2,1,0]输入：arr = [0,1,0]返回峰值元素的下标。

给你一个 从 0 开始编号 的 m x n 矩阵 mat ，其中任意两个相邻格子的值都 不相同。找出 任意一个 峰值 mat[i][j] 并 返回其位置 [i,j]。输入: mat = [[10,20,15],[21,30,14],[7,16,32]]解释: 30 和 32 都是峰值，所以[1,1]和[2,2]都是可接受的答案。解释: 3 和 4 都是峰值，所以[1,0]和[0,1]都是可接受的答案。你可以假设整个矩阵周边环绕着一圈值为 -1 的格子。输入: mat = [[1,4],[3,2]]

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。如果nums的长度为n，则此算法时间复杂度为O(logn)，空间复杂度为O(1)。你可以假设 nums[-1] = nums[n] = -∞。解释：3 是峰值元素，你的函数应该返回其索引 2。输入：nums = [1,2,1,3,5,6,4]解释：你的函数可以返回索引 1，其峰值元素为 2；输入：nums = [1,2,3,1]或者返回索引 5， 其峰值元素为 6。

请你猜选出的是哪个数字。（我选的数字在整个游戏中保持不变）。如果你猜错了，我会告诉你，我选出的数字比你猜测的数字大了还是小了。0：你猜的数字与我选出的数字相等。（即 num == pick）。-1：你猜的数字比我选出的数字大 （即 num > pick）。1：你猜的数字比我选出的数字小 （即 num < pick）。此算法时间复杂度为O(logn)，空间复杂度为O(1)。输入：n = 10, pick = 6。输入：n = 1, pick = 1。输入：n = 2, pick = 1。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。此算法时间复杂度为O(logn)，空间复杂度为O(1)。输入：n = 5, bad = 4。输入：n = 1, bad = 1。所以，4 是第一个错误的版本。

输入：root = [6,2,13,1,4,9,15,null,null,null,null,null,null,14], queries = [2,5,16]解释：树中不存在小于等于 3 的最大值，且大于等于 3 的最小值是 4。所以查询的答案是 [-1,4]。mini 是树中小于等于 queries[i] 的 最大值。如果不存在这样的值，则使用 -1 代替。输入：root = [4,null,9], queries = [3]输出：[[2,2],[4,6],[15,-1]]输出：[[-1,4]]

法二：我们可以从矩阵的右上角开始遍历，如果当前值比目标值小，那么当前值所在行左边的值一定也比目标值小，因此需要到下一行找；输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13。输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3。matrix是m行n列的，此算法时间复杂度为O(m+n)，空间复杂度为O(1)。每行的第一个整数大于前一行的最后一个整数。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。解释：8 的算术平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。如果二分上下界为n，此算法时间复杂度为O(logn)，空间复杂度为O(1)。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。

给你一个整数数组 nums 和一个整数 k ，数对由 nums[i] 和 nums[j] 组成且满足 0 <= i < j < nums.length。如果二分的上下界之差为n，nums的长度为m，则此算法时间复杂度为O(m(logm+logn))，空间复杂度为O(logm)。距离第 1 小的数对是 (1,1) ，距离为 0。输入：nums = [1,3,1], k = 1。输入：nums = [1,1,1], k = 2。输入：nums = [1,6,1], k = 3。

你能在 O(n) 的时间复杂度下解决这个问题吗?给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。输入：matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8。解释：矩阵中的元素为 [1,5,9,10,11,12,13,13,15]，第 8 小元素是 13。如果二分的上下界之差为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。请注意，它是 排序后 的第 k 小元素，而不是第 k 个 不同 的元素。

乘法表是大小为 m x n 的一个整数矩阵，其中 mat[i][j] == i * j（下标从 1 开始）。给你三个整数 m、n 和 k，请你在大小为 m x n 的乘法表中，找出并返回第 k 小的数字。此算法时间复杂度为O(min(n,m)log(mn))，空间复杂度为O(1)。几乎每一个人都用 乘法表。但是你能在乘法表中快速找到第 k 小的数字吗？输入：m = 3, n = 3, k = 5。输入：m = 2, n = 3, k = 6。解释：第 5 小的数字是 3。解释：第 6 小的数字是 6。

给定一个非负整数数组 nums 和一个整数 k ，你需要将这个数组分成 k 个非空的连续子数组，使得这 k 个子数组各自和的最大值 最小。如果nums的长度为n，二分上下界为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。其中最好的方式是将其分为 [7,2,5] 和 [10,8]。输入：nums = [7,2,5,10,8], k = 2。输入：nums = [1,2,3,4,5], k = 2。输入：nums = [1,4,4], k = 3。返回分割后最小的和的最大值。

输入：points = [[2,2],[-1,-2],[-4,4],[-3,1],[3,-3]], s = “abdca”任何正方形都无法只包含 points[0] 和 points[1] 中的一个点，所以合法正方形中都不包含任何点。输入：points = [[1,1],[-2,-2],[-2,2]], s = “abb”输入：points = [[1,1],[-1,-1],[2,-2]], s = “ccd”边长为 4 的正方形包含两个点 points[0] 和 points[1]。

解释：可以将 candies[1] 分成大小分别为 5 和 3 的两堆，然后把 candies[2] 分成大小分别为 5 和 1 的两堆。现在就有五堆大小分别为 5、5、3、5 和 1 的糖果。解释：总共有 11 个小孩，但只有 7 颗糖果，但如果要分配糖果的话，必须保证每个小孩至少能得到 1 颗糖果。另给你一个整数 k。你需要将这些糖果分配给 k 个小孩，使每个小孩分到 相同 数量的糖果。如果candies的长度为n，二分的上下界为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。

给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数，citations 已经按照 非降序排列。h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （n 篇论文中）至少 有 h 篇论文分别被引用了至少 h 次。解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 0, 1, 3, 5, 6 次。输入：citations = [0,1,3,5,6]

另给你一个长度为 n 的整数数组 dist ，其中 dist[i] 表示第 i 趟列车的行驶距离（单位是千米）。返回能满足你在时限前到达办公室所要求全部列车的 最小正整数 时速（单位：千米每小时），如果无法准时到达，则返回 -1。例如，第 1 趟列车需要 1.5 小时，那你必须再等待 0.5 小时，搭乘在第 2 小时发车的第 2 趟列车。如果dist的长度为n，二分的上下界为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。输入：dist = [1,3,2], hour = 2.7。

每辆公交车可以 连续 完成多趟旅途，也就是说，一辆公交车当前旅途完成后，可以 立马开始 下一趟旅途。如果time的长度为n，二分上下界之差为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。给你一个数组 time ，其中 time[i] 表示第 i 辆公交车完成 一趟旅途 所需要花费的时间。输入：time = [1,2,3], totalTrips = 5。输入：time = [2], totalTrips = 1。直接二分答案，二分的左边界为完成一次旅途最短的公交车的时间。

如果nums的长度为n，nums中元素的最大值为m，则此算法时间复杂度为O(nlogm)，空间复杂度为O(1)。如果除数为 4 ，我们可以得到和为 7 (1+1+2+3)。如果除数为 5 ，和为 5 (1+1+1+2)。输入：nums = [2,3,5,7,11], threshold = 11。输入：nums = [1,2,5,9], threshold = 6。解释：如果除数为 1 ，我们可以得到和为 17 （1+2+5+9）。输入：nums = [19], threshold = 5。