本文已参与「新人创作礼」活动，一起开启掘金创作之路。
1629. 按键持续时间最长的键
2022.1.9 每日一题
题目描述
LeetCode 设计了一款新式键盘，正在测试其可用性。测试人员将会点击一系列键（总计 n 个），每次一个。
给你一个长度为 n 的字符串 keysPressed ，其中 keysPressed[i] 表示测试序列中第 i 个被按下的键。releaseTimes 是一个升序排列的列表，其中 releaseTimes[i] 表示松开第 i 个键的时间。字符串和数组的 下标都从 0 开始 。第 0 个键在时间为 0 时被按下，接下来每个键都 恰好 在前一个键松开时被按下。
测试人员想要找出按键 持续时间最长 的键。第 i 次按键的持续时间为 releaseTimes[i] - releaseTimes[i - 1] ，第 0 次按键的持续时间为 releaseTimes[0] 。
注意，测试期间，同一个键可以在不同时刻被多次按下，而每次的持续时间都可能不同。
请返回按键 持续时间最长 的键，如果有多个这样的键，则返回 按字母顺序排列最大 的那个键。
示例 1：
输入：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'
示例 2：
输入：releaseTimes = [12,23,36,46,62], keysPressed = "spuda" 输出："a" 解释：按键顺序和持续时间如下： 按下 's' ，持续时间 12 按下 'p' ，持续时间 23 - 12 = 11 按下 'u' ，持续时间 36 - 23 = 13 按下 'd' ，持续时间 46 - 36 = 10 按下 'a' ，持续时间 62 - 46 = 16 按键持续时间最长的键是 'a' ，持续时间 16
提示：
releaseTimes.length == n keysPressed.length == n 2 <= n <= 1000 1 <= releaseTimes[i] <= 109 releaseTimes[i] < releaseTimes[i+1] keysPressed 仅由小写英文字母组成
来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/sl… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
模拟一下就可以了
class Solution {
public char slowestKey(int[] releaseTimes, String keysPressed) {
int time = releaseTimes[0];
char k = keysPressed.charAt(0);
int l = releaseTimes.length;
for(int i = 1; i < l; i++){
int t = releaseTimes[i] - releaseTimes[i - 1];
if(t > time || (t == time && keysPressed.charAt(i) > k)){
time = t;
k = keysPressed.charAt(i);
}
}
return k;
}
}
306. 累加数
2022.1.10 每日一题
题目描述
累加数 是一个字符串，组成它的数字可以形成累加序列。
一个有效的 累加序列 必须 至少 包含 3 个数。除了最开始的两个数以外，字符串中的其他数都等于它之前两个数相加的和。
给你一个只包含数字 '0'-'9' 的字符串，编写一个算法来判断给定输入是否是 累加数 。如果是，返回 true ；否则，返回 false 。
说明：累加序列里的数 不会 以 0 开头，所以不会出现 1, 2, 03 或者 1, 02, 3 的情况。
示例 1：
输入："112358" 输出：true 解释：累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
示例 2：
输入："199100199" 输出：true 解释：累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199
提示：
1 <= num.length <= 35 num 仅由数字（0 - 9）组成
进阶：你计划如何处理由过大的整数输入导致的溢出?
来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/ad… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
考虑大数，所以自定义加法，用字符串表示 然后遍历所有前两个数的情况，判断是否满足条件
class Solution {
public boolean isAdditiveNumber(String num) {
//遍历选取前两个数字，然后一直向后判断
//主要是要处理大数，就手动写一个相加的程序
int l = num.length();
int bound = l / 2;
//遍历长度
for(int i = 1; i <= bound; i++){
for(int j = 1; j <= bound; j++){
String x = num.substring(0, i);
String y = num.substring(i, i + j);
if(y.charAt(0) == '0' && y.length() > 1)
break;
if(helper(x, y, l, num, i + j)){
return true;
}
}
}
return false;
}
public boolean helper(String x, String y, int l, String num, int idx){
String xy = add(x, y);
//System.out.println(xy);
int len = xy.length();
int idx2 = idx + len;
if(idx2 > l)
return false;
String temp = num.substring(idx, idx2);
if(!temp.equals(xy))
return false;
if(idx2 == l)
return true;
x = y;
y = temp;
return helper(x, y, l, num, idx2);
}
public String add(String x, String y){
int lx = x.length();
int ly = y.length();
int temp = 0;
int post = 0;
StringBuffer sb = new StringBuffer();
for(int i = lx - 1, j = ly - 1; i >= 0 || j >= 0 || post != 0; i--, j--){
int a = i >= 0 ? x.charAt(i) - '0' : 0;
int b = j >= 0 ? y.charAt(j) - '0' : 0;
int t = a + b + post;
post = t / 10;
temp = t % 10;
sb.append(String.valueOf(temp));
}
return sb.reverse().toString();
}
}
1036. 逃离大迷宫
2022.1.11 每日一题
题目描述
在一个 10^6 x 10^6 的网格中，每个网格上方格的坐标为 (x, y) 。
现在从源方格 source = [sx, sy] 开始出发，意图赶往目标方格 target = [tx, ty] 。数组 blocked 是封锁的方格列表，其中每个 blocked[i] = [xi, yi] 表示坐标为 (xi, yi) 的方格是禁止通行的。
每次移动，都可以走到网格中在四个方向上相邻的方格，只要该方格 不 在给出的封锁列表 blocked 上。同时，不允许走出网格。
只有在可以通过一系列的移动从源方格 source 到达目标方格 target 时才返回 true。否则，返回 false。
示例 1：
输入：blocked = [[0,1],[1,0]], source = [0,0], target = [0,2] 输出：false 解释： 从源方格无法到达目标方格，因为我们无法在网格中移动。 无法向北或者向东移动是因为方格禁止通行。 无法向南或者向西移动是因为不能走出网格。
示例 2：
输入：blocked = [], source = [0,0], target = [999999,999999] 输出：true 解释： 因为没有方格被封锁，所以一定可以到达目标方格。
提示：
0 <= blocked.length <= 200 blocked[i].length == 2 0 <= xi, yi < 10^6 source.length == target.length == 2 0 <= sx, sy, tx, ty < 10^6 source != target 题目数据保证 source 和 target 不在封锁列表内
来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/es… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
class Solution {
int n;
int[][] blocked;
int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
Set<Pair> set;
public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {
//这个迷宫范围很大，如果暴力肯定会超时
//那么怎么做呢，看围成的范围吗，在圈内和圈外肯定走不通
//想到了在障碍点上做文章，因为障碍点相比于迷宫要小很多
//最后还是不争气的看了答案，这个方法很巧
//想一件事，就是假设障碍物围成的面积是area，那么如果从一个点出发，
//bfs经历过的点超过了area，那么说明源点并没有被围住
//如果s和t两个点都没有被围住，那么说明可以连通
//那么如果小于area，就一定被围住了吗？需要想通这点
//如果小于area，肯定是被包围住了，如果包围的范围内能走到t，也是可以的
//如果走不到，那说明t在包围圈外，是走不通的
//写一下代码
n = blocked.length;
if(n < 2)
return true;
this.blocked = blocked;
set = new HashSet<>();
for(int[] b : blocked){
set.add(new Pair(b[0], b[1]));
}
int res1 = check(source, target);
//如果在圈内，那么返回false
if(res1 == 1)
return false;
//如果能走到t，返回true
else if(res1 == 2)
return true;
//否则，看t是否在圈内
else
return check(target, source) == 0; //不在圈内
}
public int check(int[] s, int[] t){
int bound = n * (n - 1) / 2;
Queue<int[]> queue = new LinkedList<>();
queue.add(s);
Set<Pair> vis = new HashSet<>();
vis.add(new Pair(s[0], s[1]));
while(!queue.isEmpty() && bound > 0){
int[] top = queue.poll();
for(int[] d : dir){
int nx = top[0] + d[0];
int ny = top[1] + d[1];
if(nx < 0 || nx >= 1000000 || ny < 0 || ny >= 1000000)
continue;
if(set.contains(new Pair(nx, ny)) || vis.contains(new Pair(nx, ny)))
continue;
if(nx == t[0] && ny == t[1])
return 2;
bound--;
queue.add(new int[]{nx, ny});
vis.add(new Pair(nx, ny));
}
}
//如果被围住了，那么返回1
if(bound > 0)
return 1;
return 0;
}
}
class Pair{
int x;
int y;
public Pair(int x, int y){
this.x = x;
this.y = y;
}
public int hashCode(){
return x * 13131 + y;
}
public boolean equals(Object obj){
if(obj instanceof Pair){
Pair pair = (Pair)obj;
return pair.x == x && pair.y == y;
}
return false;
}
}
离散化+bfs
class Solution {
//学习一下离散化这个思路
static final int BOUNDARY = 1000000;
static final int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {
if (blocked.length < 2) {
return true;
}
// 离散化
TreeSet<Integer> rows = new TreeSet<Integer>();
TreeSet<Integer> columns = new TreeSet<Integer>();
//将行列坐标存储到treeset中进行排序
for (int[] pos : blocked) {
rows.add(pos[0]);
columns.add(pos[1]);
}
rows.add(source[0]);
rows.add(target[0]);
columns.add(source[1]);
columns.add(target[1]);
//将set中的数转换成较小的数进行排列，意味着将迷宫地图缩小
Map<Integer, Integer> rMapping = new HashMap<Integer, Integer>();
Map<Integer, Integer> cMapping = new HashMap<Integer, Integer>();
int firstRow = rows.first();
//如果第0行有值，那么就是0，否则就是1
int rId = (firstRow == 0 ? 0 : 1);
rMapping.put(firstRow, rId);
int prevRow = firstRow;
for (int row : rows) {
//如果行相同，不添加
if (row == firstRow) {
continue;
}
//如果行相邻，那么加1，如果不相邻，加2
rId += (row == prevRow + 1 ? 1 : 2);
rMapping.put(row, rId);
prevRow = row;
}
//如果最后一行不是bound-1，那么rid++，表示最后一行
if (prevRow != BOUNDARY - 1) {
++rId;
}
//同理处理列
int firstColumn = columns.first();
int cId = (firstColumn == 0 ? 0 : 1);
cMapping.put(firstColumn, cId);
int prevColumn = firstColumn;
for (int column : columns) {
if (column == firstColumn) {
continue;
}
cId += (column == prevColumn + 1 ? 1 : 2);
cMapping.put(column, cId);
prevColumn = column;
}
if (prevColumn != BOUNDARY - 1) {
++cId;
}
//然后创建这个迷宫
int[][] grid = new int[rId + 1][cId + 1];
//将这个迷宫中对应的点标记为障碍
for (int[] pos : blocked) {
int x = pos[0], y = pos[1];
grid[rMapping.get(x)][cMapping.get(y)] = 1;
}
//出发点和终点
int sx = rMapping.get(source[0]), sy = cMapping.get(source[1]);
int tx = rMapping.get(target[0]), ty = cMapping.get(target[1]);
//然后在新的迷宫中bfs
Queue<int[]> queue = new ArrayDeque<int[]>();
queue.offer(new int[]{sx, sy});
grid[sx][sy] = 1;
while (!queue.isEmpty()) {
int[] arr = queue.poll();
int x = arr[0], y = arr[1];
for (int d = 0; d < 4; ++d) {
int nx = x + dirs[d][0], ny = y + dirs[d][1];
if (nx >= 0 && nx <= rId && ny >= 0 && ny <= cId && grid[nx][ny] != 1) {
if (nx == tx && ny == ty) {
return true;
}
queue.offer(new int[]{nx, ny});
//标记已经走过了
grid[nx][ny] = 1;
}
}
}
return false;
}
}
还有一个只写了思路的思路，看不太懂，不明觉厉。。
