冱洇-优快云博客

原创 198. 打家劫舍

每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。偷窃到的最高金额 = 2 + 9 + 1 = 12。

2025-04-03 21:03:01 178

原创 401. 二进制手表

输出：[“0:01”,“0:02”,“0:04”,“0:08”,“0:16”,“0:32”,“1:00”,“2:00”,“4:00”,“8:00”]给你一个整数 turnedOn ，表示当前亮着的 LED 的数量，返回二进制手表可以表示的所有可能时间。注意到手表表示符合二进制，与通过亮灯来计算时间对应，我们也可以穷举时间，来开是否与亮灯对应。例如，“01:00” 是无效的时间，正确的写法应该是 “1:00”。例如，“10:2” 是无效的时间，正确的写法应该是 “10:02”。每次亮灯，都遍历所有情况。

2025-03-19 20:56:21 405

原创 526. 优美的排列

假设有从 1 到 n 的 n 个整数。给你一个整数 n ，返回可以构造的优美排列的数量。- perm[1] = 1 能被 i = 1 整除。- perm[2] = 2 能被 i = 2 整除。- perm[1] = 2 能被 i = 1 整除。- i = 2 能被 perm[2] = 1 整除。perm[i] 能够被 i 整除。i 能够被 perm[i] 整除。

2025-03-19 20:14:58 352

原创 397. 整数替换

值得一提的是，可以使用贪心来做，只有在末尾出现类似0011，连续两个以上的1时用+1运算，其他情况用-1，就可以得出结果。本来想用贪心直接做的，但是在输入为99999999时与结果不符，看来一味除2，-1是无法得到正确答案的。如果 n 是奇数，则可以用 n + 1或n - 1替换 n。解释：7 -> 8 -> 4 -> 2 -> 1。如果 n 是偶数，则用 n / 2替换 n。或 7 -> 6 -> 3 -> 2 -> 1。解释：8 -> 4 -> 2 -> 1。但是时间复杂度较高，应该还可以优化。

2025-03-18 20:38:49 488

原创 17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。示例 1：输入：digits = “23”输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]示例 2：输入：digits = “”输出：[]示例 3：输入：digits = “2”输出：[“a”,“b”,“c”]提示：0 <= digits.length <= 4digits[i] 是范

2025-03-18 20:08:24 555

原创 565. 数组嵌套

索引从0开始长度为N的数组A，包含0到N - 1的所有整数。找到最大的集合S并返回其大小，其中 S[i] = {A[i], A[A[i]], A[A[A[i]]], …}且遵守以下的规则。假设选择索引为i的元素A[i]为S的第一个元素，S的下一个元素应该是A[A[i]]，之后是A[A[A[i]]]…以此类推，不断添加直到S出现重复的元素。因为这题的数组元素不交叉，也可以原地标记——直接用原数组进行标记。输入: A = [5,4,0,3,1,6,2]好吧，我用的可能偏向于递归。A中不含有重复的元素。

2025-03-17 22:11:30 383

原创 387. 字符串中的第一个唯一字符

第一反应是先遍历一遍记录字符特征，再遍历一遍查找符合要求的值。但是感觉可以改进，因为要找第一次出现的不重复字符，而保存时并没有依照字符串的顺序，因此第二次必须完整遍历整个数组才行。给定一个字符串 s ，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。好吧，原来用map就可以做到，而且是一种空间换时间的做法。输入: s = “loveleetcode”输入: s = “leetcode”输入: s = “aabb”

2025-03-17 21:13:35 364

原创 2073. 买票需要的时间

tickets[k] 张。如果这个人初始在第 k 个人的前方，或者这个人恰好为第 k 个人，即 i≤k，此时在第 k 个人买完票之前他最多可以购买。如果这个人初始在第 k 个人的后方，即 i>k，此时在第 k 个人买完票之前他最多可以购买 tickets[k]−1。在最前面的人买完票后，队伍在第 1 秒变成 [1,1,1,4]。在最前面的人买完票后，队伍在第 1 秒变成 [3,2,1]。队伍一开始为 [5,1,1,1]，第 k 个人以下划线标识。队伍一开始为 [2,3,2]，第 k 个人以下划线标识。

2025-03-17 20:42:39 1382

原创 232. 用栈实现队列

你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。没有涉及队列顶部的操作时，用左栈来存数据，需要用队列顶部时，左栈交换到右栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

2025-03-14 20:51:03 324

原创 1700. 无法吃午餐的学生数量

给你两个整数数组 students 和 sandwiches ，其中 sandwiches[i] 是栈里面第 i 个三明治的类型（i = 0 是栈的顶部）， students[j] 是初始队列里第 j 名学生对三明治的喜好（j = 0 是队列的最开始位置）。输入：students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]输入：students = [1,1,0,0], sandwiches = [0,1,0,1]

2025-03-14 20:30:51 585

原创 933. 最近的请求次数

int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。// requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3。// requests = [1, 100, 3001]，范围是 [1,3001]，返回 3。// requests = [1]，范围是 [-2999,1]，返回 1。

2025-03-14 20:06:43 379

原创 414. 第三大的数

有时候正常的输入会产生错误输出，发现是一开始写的判断条件（i > second && i！此例中存在两个值为 2 的数，它们都排第二。在所有不同数字中排第三大的数为 1。给你一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。解释：注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。进阶：你能设计一个时间复杂度 O(n) 的解决方案吗？解释：第三大的数不存在, 所以返回最大的数 2。输入：[2, 2, 3, 1]解释：第三大的数是 1。输入：[3, 2, 1]

2025-03-14 19:50:21 320

原创 495. 提莫攻击

正式地讲，提莫在 t 发起攻击意味着艾希在时间区间 [t, t + duration - 1]（含 t 和 t + duration - 1）处于中毒状态。如果提莫在中毒影响结束前再次攻击，中毒状态计时器将会重置，在新的攻击之后，中毒影响将会在 duration 秒后结束。给你一个非递减的整数数组 timeSeries ，其中 timeSeries[i] 表示提莫在 timeSeries[i] 秒时对艾希发起攻击，以及一个表示中毒持续时间的整数 duration。这个做法比我的简洁一些。

2025-03-13 21:39:26 685

原创 1979. 找出数组的最大公约数

给你一个整数数组 nums ，返回数组中最大数和最小数的最大公约数。两个数的最大公约数是能够被两个数整除的最大正整数。输入：nums = [2,5,6,9,10]输入：nums = [7,5,6,8,3]2 和 10 的最大公约数是 2。3 和 8 的最大公约数是 1。输入：nums = [3,3]3 和 3 的最大公约数是 3。nums 中最大的数是 10。nums 中最小的数是 2。nums 中最小的数是 3。nums 中最大的数是 8。nums 中最小的数是 3。nums 中最大的数是 3。

2025-03-13 21:22:04 579

原创 2574. 左右元素和的差值

数组 answer 为 [|0 - 15|,|10 - 11|,|14 - 3|,|22 - 0|] = [15,1,11,22]。返回长度为 n 数组 answer，其中 answer[i] = |leftSum[i] - rightSum[i]|。解释：数组 leftSum 为 [0,10,14,22] 且数组 rightSum 为 [15,11,3,0]。解释：数组 leftSum 为 [0] 且数组 rightSum 为 [0]。数组 answer 为 [|0 - 0|] = [0]。

2025-03-13 21:02:44 360

原创 1720. 解码异或后的数组

经编码后变为长度为 n - 1 的另一个整数数组 encoded ，其中 encoded[i] = arr[i] XOR arr[i + 1]。例如，arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3]。解释：若 arr = [1,0,2,1] ，那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]输入：encoded = [1,2,3], first = 1。输出：[1,0,2,1]

2025-03-13 20:46:45 425

原创 1929. 数组串联

给你一个长度为 n 的整数数组 nums。具体而言，ans 由两个 nums 数组串联形成。输出：[1,3,2,1,1,3,2,1]输入：nums = [1,3,2,1]输入：nums = [1,2,1]输出：[1,2,1,1,2,1]也可以从循环答案数组的方向解。返回数组 ans。

2025-03-13 20:35:27 255

原创 2011. 执行操作后的变量值

输入：operations = [“X++”,“++X”,“–X”,“X–”]X++：X 加 1 ，X = -1 + 1 = 0。X++：X 加 1 ，X = 0 + 1 = 1。–X：X 减 1 ，X = 0 - 1 = -1。++X：X 加 1 ，X = 0 + 1 = 1。++X：X 加 1 ，X = 1 + 1 = 2。X++：X 加 1 ，X = 0 + 1 = 1。++X：X 加 1 ，X = 1 + 1 = 2。X–：X 减 1 ，X = 1 - 1 = 0。

2025-03-13 20:27:45 434

原创 400. 第 N 位数字

然后我想到，可以通过0-9,10-99,100-999时times每次增加的速度是不同，如果能判断出第n位数所在的那个序列数的范围，就可以将两层嵌套的while变为一层。但是降低的时间复杂度有限。给你一个整数 n ，请你在无限的整数序列 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, …解释：第 11 位数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, …我先使用了一种时间复杂度较高的方法，一位位遍历，直到满足条件，但是会在大数时超出时间限制。

2025-03-12 22:34:59 383

原创 357. 统计各位数字都不同的数字个数

解释：答案应为除去 11、22、33、44、55、66、77、88、99 外，在 0 ≤ x < 100 范围内的所有数字。看到这题我的第一个想法是排列组合，只要从0-9中选n个不同的数，然后排列，就可以得到一个符合要求的数。给你一个整数 n ，统计并返回各位数字都不同的数字 x 的个数，其中 0 <= x < 10。所以，这题就转化成了一个数学问题，套用排列组合的公式即可。感觉可以直接打表了，不过还是没有打表。所有结果相加就可以得到答案。也可以用回溯进行计算。

2025-03-11 21:16:24 367

原创 2012. 数组美丽值求和

2，对于所有 0 <= j < i 且 i < k <= nums.length - 1 ，满足 nums[j] < nums[i] < nums[k]1，如果满足 nums[i - 1] < nums[i] < nums[i + 1] ，且不满足前面的条件。返回符合 1 <= i <= nums.length - 2 的所有 nums[i] 的美丽值的总和。美丽值1和0的情况好解决，主要是美丽值为2时需要比较数组左边和右边的最值。输入：nums = [1,2,3]输入：nums = [3,2,1]

2025-03-11 20:26:34 457

原创 670. 最大交换

另一个指针从后往前找，找到最大的数，因为低位数变小，对整体变小影响最小。如果大于第一个指针的数，那么就开始交换。总体的思路是一个指针从前往后找到第一个可以换的较小数，因为高位的数增加，对整体增加影响最大。给定一个非负整数，你至多可以交换一次数字中的任意两位。返回你能得到的最大值。从后往前，可以在找到满足条件的指针的同时，减少时间复杂度。实话实说，做完感觉我这做法应该算效率低的，没想到。也可以先遍历一遍，记录大小信息，利用空间换时间。解释: 交换数字2和数字7。不过应该还有更好的方法。解释: 不需要交换。

2025-03-06 21:25:44 389

原创 168. Excel 表列名称

给你一个整数 columnNumber ，返回它在 Excel 表中相对应的列名称。输入：columnNumber = 2147483647。也可以，用sb.insert()来避免字符串最后的反转。输入：columnNumber = 701。输入：columnNumber = 28。若没有n–，则要注意处理余数为零的情况。输入：columnNumber = 1。输出：“FXSHRXW”

2025-03-06 20:37:50 958

原创 171. Excel 表列序号

给你一个字符串 columnTitle ，表示 Excel 表格中的列名称。返回该列名称对应的列序号。columnTitle 在范围 [“A”, “FXSHRXW”] 内。输入: columnTitle = “AB”输入: columnTitle = “ZY”输入: columnTitle = “A”columnTitle 仅由大写英文组成。

2025-03-05 22:01:14 588

原创 405. 数字转换为十六进制数

给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用补码运算方法。答案字符串中的所有字母都应该是小写字符，并且除了 0 本身之外，答案中不应该有任何前置零。注意: 不允许使用任何由库提供的将数字直接转换或格式化为十六进制的方法来解决这个问题。本来有对负数补码的处理，但是发现去掉也能通过就删了。老老实实按16进制转换的步骤做的，不知道除了库函数有没有更好的方法。输出：“ffffffff”也可以用位运算提取后四位。输入：num = 26。输入：num = -1。

2025-03-05 21:46:33 672

原创 319. 灯泡开关

因为如果k为n的因子，那么n/k也为n的因子。当因子个数为奇数时，k = n/k，所以只要找到1-n中有几个完全平方数即可。而直接开方就能找到，例如sqrt（45）转为int后为6 ，45包含6个完全平方数（1，4，9，16，25，36,）第三轮，你每三个灯泡就切换第三个灯泡的开关（即，打开变关闭，关闭变打开）。第 i 轮，你每 i 个灯泡就切换第 i 个灯泡的开关。接下来的第二轮，你将会每两个灯泡关闭第二个。初始时, 灯泡状态 [关闭, 关闭, 关闭].所以我遍历了1 - n，寻找有奇数个因子的灯。

2025-03-05 21:15:54 348

原创 258. 各位相加

链接：https://leetcode.cn/problems/add-digits/solutions/135092/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-5-7/26 27 28 29 30 数根: 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 1 2。我的理解是各位相加数会在0-9构成一个循环，所以只要对原数取模，就可以看出来循环到哪里了。由于 2 是一位数，所以返回 2。输入: num = 0。

2025-03-04 21:00:38 397

原创 458. 可怜的小猪

如3只小猪, 5个点. 125桶水排成一个立方体, 一只喝垂直于x轴的面, 一只喝垂直于y轴的面, 一只喝垂直于z轴的面.一只小猪代表一个维度(设为n), 每只小猪可以测试的次数+1为这只小猪在本维度上可以确定的点的数量(设为s),如n只小猪, 5个点. 5^n桶水排成一个n方体, 每只喝垂直于本维度的一个"超平面"上的所有的水.小猪喝水策略: 把所有的水桶排成一个n维的n方体, 每只小猪喝垂直于本维度(轴)的一个"超平面".则组成的n维空间中的总的点的数量为 s^n .3只小猪确定一个点(***).

2025-03-04 20:31:47 392

原创 172. 阶乘后的零

2.数学方法，幂结果中的末尾零，取决于幂本身含有的因子10的个数，或许可以从n来得到这一信息。10可以分解成2和5，其中因子2比较常见，且由阶乘的性质，如果幂含有5，则一定含有2，所以只要找到n是5的几倍即可。值得一提的是，刚开始被25给坑了，果然是复杂度为O(logn)的。进阶：你可以设计并实现对数时间复杂度的算法来解决此问题吗？给定一个整数 n ，返回 n!1.可以算出幂再依次除以10，时间复杂度为O(n）

2025-03-03 11:58:18 409

原创 393. UTF-8 编码验证

对于 n 字节的字符 (n > 1)，第一个字节的前 n 位都设为1，第 n+1 位设为 0 ，后面字节的前两位一律设为 10。按照验证规则直接遍历数组，要注意i += numBytes - 1后面跟着的-1，因为for循环最后还有i++，本质上是i += numBytes。对于 1 字节的字符，字节的第一位设为 0 ，后面 7 位为这个符号的 unicode 码。这是有效的 utf-8 编码，为一个 2 字节字符，跟着一个 1 字节字符。下一个字节是开头为 10 的延续字节，这是正确的。

2025-03-03 11:29:12 460

原创 693. 交替位二进制数

链接：https://leetcode.cn/problems/binary-number-with-alternating-bits/solutions/1374269/gong-si-shui-by-ac_oier-zuw7/ 来源：力扣（LeetCode）著作权归作者所有。当给定值 n 为交替位二进制数时，将 n 右移一位得到的值 m 仍为交替位二进制数，且与原数 n 错开一位，两者异或能够得到形如 0000…解释：11 的二进制表示是：1011.解释：7 的二进制表示是：111.

2025-03-02 21:21:06 330

原创 50. Pow(x, n)

n中每一位的1都对应了不同的n的幂，同时，每一位的1的权重不同，所以随n的左移，x要增大。实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。解释：2-2 = 1/22 = 1/4 = 0.25。输入：x = 2.00000, n = 10。输入：x = 2.00000, n = -2。输入：x = 2.10000, n = 3。要么 x 不为零，要么 n > 0。输出：1024.00000。直接调用库函数能通过编译。输出：9.26100。输出：0.25000。

2025-03-02 20:34:20 334

原创 477. 汉明距离总和

解释：在二进制表示中，4 表示为 0100 ，14 表示为 1110 ，2表示为 0010。（这样表示是为了体现后四位之间关系）给你一个整数数组 nums，请你计算并返回 nums 中任意两个数之间汉明距离的总和。两个整数的汉明距离指的是这两个数字的二进制数对应位不同的数量。计算32位int中的每一位会产生的海明距离，然后再求和。给定输入的对应答案符合 32-bit 整数范围。将数组元素化零为整，作为一个整体来看待。输入：nums = [4,14,2]输入：nums = [4,14,4]

2025-03-02 20:05:41 352

原创 461. 汉明距离

也可以利用s &（s - 1）来不断消去异或结果的最右端1并计数来得到结果。两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。注意：本题与 2220. 转换数字的最少位翻转次数相同。给你两个整数 x 和 y，计算并返回它们之间的汉明距离。上面的箭头指出了对应二进制位不同的位置。直接调用库函数统计x，y的相异位。输入：x = 1, y = 4。输入：x = 3, y = 1。

2025-03-02 19:53:48 335

原创 476. 数字的补数

例如，整数 5 的二进制表示是 “101” ，取反后得到 “010” ，再转回十进制表示得到补数 2。利用times计算最高位1的位置，再用times生成全为1的二进制数，与num异或取反后即可得到答案。对整数的二进制表示取反（0 变 1 ，1 变 0）后，再转换为十进制表示，可以得到这个整数的补数。只要找到对应的2的幂10000，利用等式10000 - 1 - 1001 就可得出1001的补数。解释：1 的二进制表示为 1（没有前导零位），其补数为 0。给你一个整数 num ，输出它的补数。

2025-02-26 21:31:54 233

原创 191. 位1的个数

给定一个正整数 n，编写一个函数，获取一个正整数的二进制形式并返回其二进制表达式中设置位的个数（也被称为汉明重量）。解释：输入的二进制串 1111111111111111111111111111101 中，共有 30 个设置位。也可以用n &= n - 1不断消除二进制的最后一位1，通过计算需要消除1的次数来计算1的个数。解释：输入的二进制串 10000000 中，共有 1 个设置位。解释：输入的二进制串 1011 中，共有 3 个设置位。输入：n = 2147483645。输入：n = 128。

2025-02-26 21:05:11 195

空空如也

空空如也