8-周赛334总结

最新推荐文章于 2024-11-09 22:20:02 发布

TIkitianya

最新推荐文章于 2024-11-09 22:20:02 发布

阅读量207

点赞数

分类专栏：周赛文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/Tikitian/article/details/129256519

版权

周赛专栏收录该内容

17 篇文章 1 订阅

订阅专栏

8-周赛334总结

终于过了三题，第二题卡了很久，最后才灵光一现。然后第四题就来不及做了，太着急了，卡在了反复移动计算时间点上。这周继续努力啦

左右元素和的差值【LC2574】

给你一个下标从 0 开始的整数数组 nums ，请你找出一个下标从 0 开始的整数数组 answer ，其中：

answer.length == nums.length
answer[i] = |leftSum[i] - rightSum[i]|

其中：

leftSum[i] 是数组 nums 中下标 i 左侧元素之和。如果不存在对应的元素，leftSum[i] = 0 。
rightSum[i] 是数组 nums 中下标 i 右侧元素之和。如果不存在对应的元素，rightSum[i] = 0 。

返回数组 answer 。

思路：简单模拟

按照要求求出leftSum[i]和rightSum[i]，然后计算出answer[i] = |leftSum[i] - rightSum[i]|

class Solution {
    public int[] leftRigthDifference(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
        int[] left = new int[n];
        int[] right = new int[n];
        for (int i = 1; i < n; i++){
            left[i] = left[i - 1] + nums[i - 1];
        }
        for (int i = n - 2; i >= 0; i--){
            right[i] = right[i + 1] + nums[i + 1];
        }
        for (int i = 0; i < n; i ++){
            res[i] = Math.abs(left[i] - right[i]);
        }
        return res;

    }
}

复杂度
- 时间复杂度： $O (n)$
- 空间复杂度： $O (n)$

优化：一个循环计算left和right

class Solution {
    public int[] leftRigthDifference(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];
        int[] left = new int[n];
        int[] right = new int[n];
        for (int i = 1; i < n; i++){
            left[i] = left[i - 1] + nums[i - 1];
            right[n - i - 1] = right[n - i] + nums[n - i];
        }
        for (int i = 0; i < n; i ++){
            res[i] = Math.abs(left[i] - right[i]);
        }
        return res;

    }
}

找出字符串的可整除数组【LC2575】

给你一个下标从 0 开始的字符串 word ，长度为 n ，由从 0 到 9 的数字组成。另给你一个正整数 m 。

word 的 可整除数组 div 是一个长度为 n 的整数数组，并满足：

如果 word[0,...,i] 所表示的数值能被 m 整除，div[i] = 1
否则，div[i] = 0

返回 word 的可整除数组。

思路【重点在于如何处理越界卡了贼久】
- 使用变量cur记录word[0,i]的整数值，如果该值能被m整除，那么ans[i]=1
- 由于字符串的长度 $\le n \le 10^5$ ，那么无论用int或者long类型存储cur遍历过程中一定会越界（BigInteger会超时），那么如何处理越界的问题成了关键。
- 我们需要关注的情况是cur能被m整除，也就是说余数为0，那么可以只记录累计余数的数值，因为商是m的倍数，在移动i的过程中扩大了10倍，仍是m的倍数，因此可以省略不记！
- 还需要注意的是 $\le m \le 10^9$ ，如果遍历过程中，余数cur的值很大时，再乘以10倍，需要使用long类型记录结果，使用int类型会存在越界
```
class Solution {
    public int[] divisibilityArray(String word, int m) {
        int n = word.length();
        int[] res = new int[n];
        long cur = 0L;
        for (int i = 0; i < n; i++){
            cur = (cur * 10 + word.charAt(i) - '0') % m;
            if (cur == 0){
                res[i] = 1;
            }     
        }
        return res;

    }
}
```
- 复杂度
  - 时间复杂度： $O (n)$
  - 空间复杂度： $O (1)$

求出最多标记下标【LC2576】

给你一个下标从 0 开始的整数数组 nums 。

一开始，所有下标都没有被标记。你可以执行以下操作任意次：

选择两个 互不相同且未标记 的下标 i 和 j ，满足 2 * nums[i] <= nums[j] ，标记下标 i 和 j 。

请你执行上述操作任意次，返回 nums 中最多可以标记的下标数目。

贪心+双指针

思路：贪心+双指针

如果数组中每一个数都有对应的数可以匹配，那么最多有 $n /2$ 对，并且将数组从小到大排序后，一定是nums[i]匹配nums[n/2+i]
- 因为将数组从小到大排序后nms[i]能匹配nums[n/2+i]的话，就一定能匹配nums[n/2+i]之后的数组，所以为了使能够匹配的对数最多，我们应该使较小的数值优先匹配在后半个数组中首次匹配到的数字【局部最优】
因此，可以将数组从小到大排序后，将数组分为前后两个部分 $n u m s [0, n /2)$ 和 $n u m s [n /2 : n)$ ，使用左指针 $l$ 指向前半个数组的第一个元素，使用右指针 $r$ 指向后半个数组的第二个元素，根据大小情况，移动指针
- 如果 $\le nums[r]$ ，那么有可以匹配的对数，同时移动左右指针
- 否则，只移动右指针
最后总对数即为 $2 * l$

实现

class Solution {
    public int maxNumOfMarkedIndices(int[] nums) {
        int res = 0, n = nums.length;
        Arrays.sort(nums);
        int l = 0;
        int r = n / 2 ;
        while (l < n / 2 && r < n){
            if (nums[l] * 2 <= nums[r]){
                // res += 2;
                l++;
                r++;
            }else{
                r++;
            }
        }
        return 2 * l;
    
    }
}

复杂度
- 时间复杂度： $O (n)$
- 空间复杂度： $O (1)$

在网格图中访问一个格子的最少时间【LC2577】

给你一个 m x n 的矩阵 grid ，每个元素都为非负整数，其中 grid[row][col] 表示可以访问格子 (row, col) 的最早时间。也就是说当你访问格子 (row, col) 时，最少已经经过的时间为 grid[row][col] 。

你从 最左上角 出发，出发时刻为 0 ，你必须一直移动到上下左右相邻四个格子中的任意一个格子（即不能停留在格子上）。每次移动都需要花费 1 单位时间。

请你返回最早到达右下角格子的时间，如果你无法到达右下角的格子，请你返回 -1 。

思路：BFS+最短路径
- 由于需要求出访问到右下角的最早时间，每次只能移动一格，也就是最短路径，因此可以考虑使用最短路径Dijkstra 算法求最短路径。
- 由于每个时间点必须移动一次，并且可以移动到访问过的格子，因此，如果我们从原点可以访问到相邻的格子，那么每个格子均能被访问到；否则，只能停留在原点。那么假设走到格子 $x_1,y_1]$ 的最早时间为 $t_1$ ，走到相邻格子 $x_2,y_2]$ 的最早时间为 $t_2$
  - 如果 $t_1+1 \ge grid[x_2][y_2]$ ，那么我们可以直接从 $x_1,y_1]$ 走到 $x_2,y_2]$ ，那么 $t_2=t_1+1$
  - 否则，如果 $t_1+1 \lt grid[x_2][y_2]$ ，那么我们需要在格子 $x_1,y_1]$ 和上一个格子之间进行反复移动，直到可以进入格子 $x_2,y_2]$ ，那么反复移动的时间为$\lfloor (grid[x_2][y_2]-t_1)/2 \rfloor $次，在时间$ t_1 + \lfloor (grid[x_2][y_2]-t_1)/2 \rfloor * 2 $回到$ [x_1,y_1] $，那么$ t_2=t_1 + \lfloor (grid[x_2][y_2]-t_1)/2 \rfloor * 2+1$
- 实现时，使用BFS和优先队列实现，优先队列存储三元组 $[x, y, t im e]$ ，以时间升序排序，保证到达右下角时的时间是最小的，每次将未访问过的格子对应的三元组放入优先队列中，直至到达右下角

实现

class Solution {
    public int minimumTime(int[][] grid) { 
        int m = grid.length, n = grid[0].length;
        int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
        if (grid[1][0] > 1 && grid[0][1] > 1 ) return -1;// 无法达到右下角
        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[2] - o2[2]);
        pq.add(new int[]{0, 0, 0});
        boolean[][] visited = new boolean[m][n];// 存储最短时间
        visited[0][0] = true;   
        while(!pq.isEmpty()){
            int[] pos = pq.poll();
            for (int j = 0; j < 4; j++){
                int nextX = pos[0] + dir[j][0];
                int nextY = pos[1] + dir[j][1];
                if (nextX >= 0 && nextX < m && nextY >= 0 && nextY < n && !visited[nextX][nextY]){
                    int t = pos[2] + 1;// grid[nextX][nextY] <= pos[2] 直接走进
                    // 来回等待时间
                    if (grid[nextX][nextY] > pos[2] + 1){
                        t += (grid[nextX][nextY] - pos[2]) / 2 * 2;// 等待的时间
                    }
                    if (nextX == m - 1 && nextY == n - 1) return t;
                    pq.add(new int[]{nextX, nextY, t});
                    visited[nextX][nextY] = true;
                    
                }
            }
        }
        return -1;
    }
    
}