LeetCode 1629. 按键持续时间最长的键 / 306. 累加数 / 1036. 逃离大迷宫（有范围的bfs、离散化+bfs）

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）
链接：https://leetcode-cn.com/problems/slowest-key
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

模拟一下就可以了

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）
链接：https://leetcode-cn.com/problems/additive-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

考虑大数，所以自定义加法，用字符串表示
然后遍历所有前两个数的情况，判断是否满足条件

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）
链接：https://leetcode-cn.com/problems/escape-a-large-maze
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

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;
    }
}

还有一个只写了思路的思路，看不太懂，不明觉厉。。