目录（每日一题）

1614. 括号的最大嵌套深度
89. 格雷编码
1629. 按键持续时间最长的键
306. 累加数
1036. 逃离大迷宫
334. 递增的三元子序列
747. 至少是其他数字两倍的最大数
373. 查找和最小的K对数字
1716. 计算力扣银行的钱
382. 链表随机节点

1614. 括号的最大嵌套深度

如果字符串满足以下条件之一，则可以称之为有效括号字符串（valid parentheses string，可以简写为 VPS）：

字符串是一个空字符串 “”，或者是一个不为 “(” 或 “)” 的单字符。
字符串可以写为 AB（A 与 B 字符串连接），其中 A 和 B 都是有效括号字符串。
字符串可以写为 (A)，其中 A 是一个有效括号字符串。

类似地，可以定义任何有效括号字符串 S 的嵌套深度 depth(S)：
depth("") = 0
depth© = 0，其中 C 是单个字符的字符串，且该字符不是 “(” 或者 “)”
depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是有效括号字符串
depth("(" + A + “)”) = 1 + depth(A)，其中 A 是一个有效括号字符串
例如：""、"()()"、"()(()())" 都是有效括号字符串（嵌套深度分别为 0、1、2），而 “)(” 、"(()" 都不是有效括号字符串。

给你一个有效括号字符串 s，返回该字符串的 s 嵌套深度。

public int maxDepth(String s) {// dep保存当前嵌套的数量int dep = 0;// 保存最大括号嵌套深度int maxDep = 0;char[] chars = s.toCharArray();for(int i = 0;i<chars.length;i++){if(chars[i] == '('){//当前深度++dep++;// 如果大于最大深度，则更新最大深度if(maxDep < dep){maxDep = dep;}}else if(chars[i] == ')'){// 遇到右括号，当前深度--dep--;}}return maxDep;
}

89. 格雷编码

n 位格雷码序列是一个由 2n 个整数组成的序列，其中：

每个整数都在范围 [0, 2ⁿ - 1] 内（含 0 和 2ⁿ - 1）
第一个整数是 0
一个整数在序列中出现不超过一次
每对相邻整数的二进制表示恰好一位不同
第一个和最后一个整数的二进制表示恰好一位不同

给你一个整数 n ，返回任一有效的 n 位格雷码序列。

示例：

输入：n = 2
输出：[0,1,3,2]
解释：
[0,1,3,2] 的二进制表示是 [00,01,11,10] 。
- 00 和 01 有一位不同
- 01 和 11 有一位不同
- 11 和 10 有一位不同
- 10 和 00 有一位不同
[0,2,3,1] 也是一个有效的格雷码序列，其二进制表示是 [00,10,11,01] 。
- 00 和 10 有一位不同
- 10 和 11 有一位不同
- 11 和 01 有一位不同
- 01 和 00 有一位不同

方法一：根据格雷码的定义求解
第 i 位的格雷码为 i >> 1 ^ i
如第五位： 101 >> 1 ^ 101 = 010 ^ 101 = 111

public List<Integer> grayCode(int n) {List<Integer> ret = new ArrayList<>();for (int i = 0; i < 1 << n; i++) {ret.add((i >> 1) ^ i);}return ret;
}

方法二：镜像求解，最高位 | 1
例：n = 2
格雷码为 0 1 3 2，二进制为 00，01，11,10
分为两部分 00，01和 11，10。将第二部分反转变成 10，11观察与第一部分区别，只要在第一部分最高为 | 1即可得到。

public List<Integer> grayCode(int n) {List<Integer> res = new ArrayList<>();res.add(0);res.add(1);for(int i = 1;i < n;i++){for(int j = res.size() - 1;j >= 0;j--){res.add(res.get(j)| 1 << i);}}return res;
}

1629. 按键持续时间最长的键

LeetCode 设计了一款新式键盘，正在测试其可用性。测试人员将会点击一系列键（总计 n 个），每次一个。
给你一个长度为 n 的字符串 keysPressed ，其中 keysPressed[i] 表示测试序列中第 i 个被按下的键。releaseTimes 是一个升序排列的列表，其中 releaseTimes[i] 表示松开第 i 个键的时间。字符串和数组的下标都从 0 开始。第 0 个键在时间为 0 时被按下，接下来每个键都恰好在前一个键松开时被按下。
测试人员想要找出按键持续时间最长的键。第 i 次按键的持续时间为releaseTimes[i]-releaseTimes[i - 1] ，第 0 次按键的持续时间为 releaseTimes[0] 。
注意，测试期间，同一个键可以在不同时刻被多次按下，而每次的持续时间都可能不同。
请返回按键持续时间最长的键，如果有多个这样的键，则返回按字母顺序排列最大的那个键。
（注意，单次按下持续时间最长的键）

示例：

输入：releaseTimes = [9,29,49,50], keysPressed = "cbcd"
输出："c"
解释：按键顺序和持续时间如下：
按下 'c' ，持续时间 9（时间 0 按下，时间 9 松开）
按下 'b' ，持续时间 29 - 9 = 20（松开上一个键的时间 9 按下，时间 29 松开）
按下 'c' ，持续时间 49 - 29 = 20（松开上一个键的时间 29 按下，时间 49 松开）
按下 'd' ，持续时间 50 - 49 = 1（松开上一个键的时间 49 按下，时间 50 松开）
按键持续时间最长的键是 'b' 和 'c'（第二次按下时），持续时间都是 20
'c' 按字母顺序排列比 'b' 大，所以答案是 'c'

public char slowestKey(int[] releaseTimes, String keysPressed) {// 记录最大持续时间int maxTime = -1;char c = 'a';int pre = 0;// 记录单次持续时间int releaseTime;for(int i = 0; i < releaseTimes.length;i++) {releaseTime = releaseTimes[i] - pre;pre = releaseTimes[i];// 如果单次持续按键时间大于历史最大时间// 或等于历史最大时间，如果字母序列大于持续最大时间的字母按键，则进行更新if (releaseTime > maxTime || (releaseTime == maxTime && keysPressed.charAt(i) > c)) {maxTime = releaseTime;c = keysPressed.charAt(i);}}return c;
}

306. 累加数

累加数是一个字符串，组成它的数字可以形成累加序列。
一个有效的累加序列必须至少包含 3 个数。除了最开始的两个数以外，字符串中的其他数都等于它之前两个数相加的和。
给你一个只包含数字 ‘0’-‘9’ 的字符串，编写一个算法来判断给定输入是否是累加数。如果是，返回 true ；否则，返回 false 。
说明：累加序列里的数不会以 0 开头，所以不会出现 1, 2, 03 或者 1, 02, 3 的情况。

示例：

输入："199100199"
输出：true
解释：累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199

提示：

1 <= num.length <= 35
num 仅由数字（0 - 9）组成

解题思路：dfs

public boolean isAdditiveNumber(String num) {long first,second;// 遍历第一个数for(int i = 0;i < num.length() - 1;i++){//  不能为前导0的数if(num.charAt(0) == '0' && i > 0){return false;}first = Long.parseLong(num.substring(0, i + 1));// 遍历第二个数for(int j = i + 1; j < num.length() - 1;j++){// 不能为前导0的数if(num.charAt(i + 1) == '0' && j > i + 1){break;}second = Long.parseLong(num.substring(i + 1, j + 1));// 判断当前第一个和第二个是满足累加序列if(dfs(num,first,second,j + 1)) {return true;}}}return false;
}
public boolean dfs(String nums,long first,long second,int index){// 走到头，满足累加序列，返回trueif(index == nums.length()){return true;}// 遍历第三个数 for(int i = index;i < nums.length();i++){// 不能为前导0的数if(nums.charAt(index) == '0' && i > index){return false;}long thirdly = Long.parseLong(nums.substring(index,i + 1));// 第三个数大于 第一个数与第二个数之和，不能再往后遍历，进行剪枝if(thirdly > first + second){// 剪枝return false;}// 第三个数等于第一个数与第二个数之和，继续dfsif(thirdly == first + second){if(dfs(nums,second,thirdly,i + 1)){return true;}else{return false;}}}return false;
}

1036. 逃离大迷宫

在一个 10⁶ x 10⁶ 的网格中，每个网格上方格的坐标为 (x, y) 。
现在从源方格 source = [sx, sy] 开始出发，意图赶往目标方格 target = [tx, ty] 。数组 blocked 是封锁的方格列表，其中每个 blocked[i] = [xi, yi] 表示坐标为 (xi, yi) 的方格是禁止通行的。

每次移动，都可以走到网格中在四个方向上相邻的方格，只要该方格不在给出的封锁列表 blocked 上。同时，不允许走出网格。

只有在可以通过一系列的移动从源方格 source 到达目标方格 target 时才返回 true。否则，返回 false。

示例：

输入：blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
输出：false
解释：
从源方格无法到达目标方格，因为我们无法在网格中移动。
无法向北或者向东移动是因为方格禁止通行。
无法向南或者向西移动是因为不能走出网格。

提示：

0 <= blocked.length <= 200
blocked[i].length == 2
0 <= xi, yi < 10⁶
source.length == target.length == 2
0 <= sx, sy, tx, ty < 10⁶
source != target
题目数据保证 source 和 target 不在封锁列表内

解题思路：使用 BFS，从 source点和target点同时向外搜索。对于不联通的情况，是blocked 中的点将一个点包围起来，另一个点在包围圈外面。blocked 中的点最大为200个，能包围的最大点数为 200*(200-1)/2个。
如图：借助两个边，包围面积达到最大值。

所以在BFS时进行优化，只要从 source开始能访问的点的个数比最大包围的点数大，就说明source点没有被包围，同理 target也是。只要两个点都没有被包围，则可以联通。

public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {// 记录不能走的点HashSet<Long> blockedSet = new HashSet<>();// 分别记录source访问过的位置，target访问过的位置。HashSet<Long> sourceSet = new HashSet<>();HashSet<Long> targetSet = new HashSet<>();// 使用 BFS用到的两个队列Queue<Long> sourceQueue = new ArrayDeque<>();Queue<Long> targetQueue = new ArrayDeque<>();// 200个障碍最大的包围的面积int MAXSIZE = 200*(200-1)/2;            // 边界值Long BORDER = 1000000L;                // 位置int[][] dir = new int[][]{{0,1},{0,-1},{1,0},{-1,0}};for(int i = 0; i<blocked.length;i++){blockedSet.add(blocked[i][0] * BORDER + blocked[i][1]);}sourceQueue.add(source[0] * BORDER + source[1]);targetQueue.add(target[0] * BORDER + target[1]);sourceSet.add(source[0] * BORDER + source[1]);targetSet.add(target[0] * BORDER + target[1]);while(!sourceQueue.isEmpty() && !targetQueue.isEmpty()){// 从 source和target出发同时BFSLong sourceVis = sourceQueue.poll();Long targetVis = targetQueue.poll();Long sx = sourceVis / BORDER;Long sy = sourceVis % BORDER;Long tx = targetVis / BORDER;Long ty = targetVis % BORDER;for(int di = 0;di < 4;di++){Long newsx = sx + dir[di][0];Long newsy = sy + dir[di][1];Long newtx = tx + dir[di][0];Long newty = ty + dir[di][1];// 判断位置是否合法，且没有被访问过或被封锁if(newsx < 0 || newsx >= BORDER || newsy < 0 || newsy >= BORDER ||sourceSet.contains(newsx*BORDER+newsy) || blockedSet.contains(newsx*BORDER+newsy)){}else {// 判断该位置target是否已经访问过，若访问过，说明联通if(targetSet.contains(newsx*BORDER+newsy)){return true;}sourceQueue.add(newsx*BORDER+newsy);sourceSet.add(newsx*BORDER+newsy);}// 判断位置是否合法，且没有被访问过或被封锁if(newtx < 0 || newtx >= BORDER || newty < 0 || newty >= BORDER ||targetSet.contains(newtx*BORDER+newty) ||blockedSet.contains(newtx*BORDER+newty)){}else {// 判断该位置source是否已经访问过，若访问过，说明联通 if(sourceSet.contains(newtx*BORDER+newty)){return true;}targetQueue.add(newtx*BORDER+newty);targetSet.add(newtx*BORDER+newty);}}// 判断是否都没有被包围，是则联通if(sourceSet.size() > MAXSIZE && targetSet.size() > MAXSIZE){return true;}}return false;
}

334. 递增的三元子序列

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。
如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

示例：

输入：nums = [2,1,5,0,4,6]
输出：true
解释：三元组 (3, 4, 5) 满足题意，因为 nums[3] == 0 < nums[4] == 4 < nums[5] == 6

提示：

1 <= nums.length <= 5 * 105
-2³¹ <= nums[i] <= 2³¹ - 1

进阶：你能实现时间复杂度为 O(n) ，空间复杂度为 O(1) 的解决方案吗？

解题思路：记录当前序列中最小的数和最大的数，如果出现比最大的数还大的数，则找到递增的三元子序列，返回true。

public boolean increasingTriplet(int[] nums) {int len = nums.length;int min = Integer.MAX_VALUE,mid = Integer.MAX_VALUE;for(int i = 0;i < len;i++){if(nums[i] <= min){min = nums[i];}else if(nums[i] < mid){mid = nums[i];}else if(nums[i] > mid){return true;}}return false;
}

747. 至少是其他数字两倍的最大数

给你一个整数数组 nums ，其中总是存在唯一的一个最大整数。

请你找出数组中的最大元素并检查它是否至少是数组中每个其他数字的两倍。如果是，则返回最大元素的下标，否则返回 -1 。

示例：

输入：nums = [3,6,1,0]
输出：1
解释：6 是最大的整数，对于数组中的其他整数，6 大于数组中其他元素的两倍。6 的下标是 1 ，所以返回 1 。

提示：

1 <= nums.length <= 50
0 <= nums[i] <= 100
nums 中的最大元素是唯一的

解题思路：遍历，找到最大的数和次大的数。然后判断最大的数，是不是次大的数的二倍。

public int dominantIndex(int[] nums) {int len = nums.length;if(len == 1){return 0;}// 初始化最大数和次大数的下标int first,second;if(nums[0] > nums[1]){first = 0;second = 1;}else{first = 1;second = 0;}// 遍历for(int i = 2; i < len;i++){if(nums[i] > nums[first]){second = first;first = i;} else if(nums[i] > nums[second]){second = i;}}// 判断结果并返回return nums[first] >= nums[second] * 2 ? first : -1;
}

373. 查找和最小的K对数字

给定两个以升序排列的整数数组 nums1 和 nums2 , 以及一个整数 k 。
定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。
请找到和最小的 k 个数对 (u1,v1), (u2,v2) … (uk,vk) 。

示例：

输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
输出: [1,2],[1,4],[1,6]
解释: 返回序列中的前 3 对数：[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]

提示:

1 <= nums1.length, nums2.length <= 10⁴
-10⁹ <= nums1[i], nums2[i] <= 10⁹
nums1, nums2 均为升序排列
1 <= k <= 1000

这个题跟378. 有序矩阵中第 K 小的元素解法一样。所有的nums1中的元素和nums2中的元素，两两相加，组成了一个二维矩阵。nums1的长度为 n，nums2的长度为 m。那么矩阵的大小为 n*m。
如示例中的nums1和nums2组成的结果矩阵为：

matrix[n][m] =    2     4       6           // 横为nums2中的所有元素，nums1中的所有元素1        [ 3     6       94        5     8       117       7     10      13  ]

从结果矩阵中取出前k个最小的元素。

解题思路：使用优先队列存储结果矩阵值组成的两个下标，多路归并，归并到第k个最小的值时停止。

public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {int n = nums1.length;int m = nums2.length;// 使用优先队列对nums1+nums2组成的值进行排序PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(k,Comparator.comparingInt(a -> (nums1[a[0]] + nums2[a[1]])));// 将每一行看成一个数组，对多个数组进行归并，现将所有的数组的头元素入队列for(int i = 0;i < Math.min(n,k);i++){priorityQueue.add(new int[]{i,0});}List<List<Integer>> ans = new ArrayList<>();List<Integer> tmp;// 多路归并for(int i = 0; i < k && !priorityQueue.isEmpty();i++){// 取出队列中最小的元素int[] t = priorityQueue.poll();tmp = new ArrayList<>();tmp.add(nums1[t[0]]);tmp.add(nums2[t[1]]);// 加入结果集ans.add(tmp);// 如果数组还有下一个元素，继续入队列if(t[1] + 1 < m){priorityQueue.add(new int[]{t[0],t[1] + 1});}}// 返回结果return ans;
}

1716. 计算力扣银行的钱

Hercy 想要为购买第一辆车存钱。他每天都往力扣银行里存钱。
最开始，他在周一的时候存入 1 块钱。从周二到周日，他每天都比前一天多存入 1 块钱。在接下来每一个周一，他都会比前一个周一多存入 1 块钱。
给你 n ，请你返回在第 n 天结束的时候他在力扣银行总共存了多少块钱。

示例：

输入：n = 20
输出：96
解释：第 20 天后，总额为 (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4 + 5 + 6 + 7 + 8) + (3 + 4 + 5 + 6 + 7 + 8) = 96 。

解题思路：模拟法。

public int totalMoney(int n) {// 多少周int a = n / 7;// 剩余天数int b = n % 7;// 先算一共有多少周,第一周为 28，以后每周+7int ans = 0;for (int i = 0; i < a; i++) {ans += 28 + i * 7;}// 再算剩余的天数for (int i = 0; i < b; i++) {ans += ++a;}return ans;
}

382. 链表随机节点

给你一个单链表，随机选择链表的一个节点，并返回相应的节点值。每个节点被选中的概率一样。

实现 Solution 类：

Solution(ListNode head) 使用整数数组初始化对象。
int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。

示例：

输入
["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
[[[1, 2, 3]], [], [], [], [], []]
输出
[null, 1, 3, 2, 2, 3]
解释
Solution solution = new Solution([1, 2, 3]);
solution.getRandom(); // 返回 1
solution.getRandom(); // 返回 3
solution.getRandom(); // 返回 2
solution.getRandom(); // 返回 2
solution.getRandom(); // 返回 3
// getRandom() 方法应随机返回 1、2、3中的一个，每个元素被返回的概率相等。

方法一：在类中使用数组将链表中的数据记录下来，在获得随机元素时候，将数组中的对应下标元素返回即可。

class Solution {List<Integer> list = new ArrayList<>();Random random = new Random();public Solution(ListNode head) {while(head != null){list.add(head.val);head = head.next;}}public int getRandom() {return list.get(random.nextInt(list.size()));}
}

方法二：水塘抽样
从链表头开始，遍历整个链表，对遍历到的第 i 个节点，随机选择区间 [0,i) 内的一个整数，如果其等于 0，则将答案置为该节点值，否则答案不变。
该算法会保证每个节点的值成为最后被返回的值的概率均为 1/n。
每次只保留一个数，当遇到第 i 个数时，以 1/i的概率保留它，(i-1)/i的概率保留原来的数。
举例说明： 1 - 10
遇到1，概率为1，保留第一个数。
遇到2，概率为1/2，这个时候，1和2各1/2的概率被保留
遇到3，3被保留的概率为1/3，(之前剩下的数假设1被保留)，2/3的概率 1 被保留，(此时1被保留的总概率为 2/3 * 1/2 = 1/3)
遇到4，4被保留的概率为1/4，(之前剩下的数假设1被保留)，3/4的概率 1 被保留，(此时1被保留的总概率为 3/4 * 2/3 * 1/2 = 1/4)
以此类推，每个数被保留的概率都是1/N。

class Solution {ListNode head;Random random;public Solution(ListNode head) {this.head = head;random = new Random();}public int getRandom() {int i = 1;int result = 0;for(ListNode node = head; node != null;node = node.next){if(random.nextInt(i) == 0){result = node.val;}i++;}return result;}
}

LeetCode每日一题(22年1月7日-1月16日)相关推荐

Leetcode每日一题:22.generate-parentheses(括号生成)
本题分别采用两种方法:暴力法(set+vector) 以及 dfs(vector) vector<string> generateParenthesis(int n) {set<st ...
4月你好，愚人节果然是笨人，【LeetCode每日一题】1006. 笨阶乘
4月你好,愚人节果然是笨人,[LeetCode每日一题]1006. 笨阶乘今日题目1006题,每日一题微信交流群可以点击右下角:合作转载->联系我,拉你入群. 目前每日一题两个群,每天推送题目 ...
leetcode每日刷题计划-简单篇day8
leetcode每日刷题计划-简单篇day8 今天是纠结要不要新买手机的一天QAQ想了想还是算了吧,等自己赚钱买,加油 Num 70 爬楼梯 Climbing Stairs class Solutio ...
Leetcode每日一题：171.excel-sheet-column-number(Excel表列序号)
思路:就是168题的反命题,进制的方式完美解决: Leetcode每日一题:168.excel-sheet-column-title(Excel表名称) class Solution {public: ...
【LeetCode每日一题】1723. 完成所有工作的最短时间
[LeetCode每日一题]1723. 完成所有工作的最短时间 [1] 1723. 完成所有工作的最短时间 [2] 473. 火柴拼正方形 [1] 1723. 完成所有工作的最短时间题目: 给你一个 ...
leetcode每日一题--雀巢原理；抽屉算法；Quorum机制；分布式应用
leetcode每日一题 539. 最小时间差示例 1: 输入:timePoints = ["23:59","00:00"] 输出:1 示例 2: 输入:ti ...
LeetCode每日一题——1812. 判断国际象棋棋盘中一个格子的颜色
LeetCode每日一题系列题目:1812. 判断国际象棋棋盘中一个格子的颜色难度:简单文章目录 LeetCode每日一题系列题目示例思路题解题目给你一个坐标 coordinates ...
【LeetCode每日一题】——109.有序链表转换二叉搜索树
文章目录一[题目类别] 二[题目难度] 三[题目编号] 四[题目描述] 五[题目示例] 六[题目提示] 七[解题思路] 八[时间频度] 九[代码实现] 十[提交结果] 一[题目类别] 二叉树二[题 ...
leetcode每日一题·救生艇问题(Python)
leetcode每日一题·救生艇问题(Python) 问题描述题目入口题目思路首先分析问题,一个船最多坐两人,因此我们可以把这个问题看作两两组合的问题,并且如果最重的那个人和最轻的人加起来大于l ...

LeetCode每日一题(22年1月7日-1月16日)

目录（每日一题）

1614. 括号的最大嵌套深度

89. 格雷编码

1629. 按键持续时间最长的键

306. 累加数

1036. 逃离大迷宫

334. 递增的三元子序列

747. 至少是其他数字两倍的最大数

373. 查找和最小的K对数字

1716. 计算力扣银行的钱

382. 链表随机节点

LeetCode每日一题(22年1月7日-1月16日)相关推荐

最新文章

热门文章