LeetCode Weekly Contest 195

最新推荐文章于 2022-10-14 00:06:10 发布

da_kao_la

最新推荐文章于 2022-10-14 00:06:10 发布

阅读量318

点赞数

分类专栏： LeetCode 文章标签： LeetCode 周赛乘方取模滑动窗口

本文链接：https://blog.csdn.net/da_kao_la/article/details/107000963

版权

LeetCode 专栏收录该内容

371 篇文章 0 订阅

订阅专栏

5448. 判断路径是否相交

给你一个字符串 path，其中 path[i] 的值可以是 ‘N’、‘S’、‘E’ 或者 ‘W’，分别表示向北、向南、向东、向西移动一个单位。

机器人从二维平面上的原点 (0, 0) 处开始出发，按 path 所指示的路径行走。

如果路径在任何位置上出现相交的情况，也就是走到之前已经走过的位置，请返回 True ；否则，返回 False 。

示例 1：

输入：path = “NES”
输出：false
解释：该路径没有在任何位置相交。
示例 2：

输入：path = “NESWW”
输出：true
解释：该路径经过原点两次。

提示：

1 <= path.length <= 10^4
path 仅由 {‘N’, ‘S’, ‘E’, 'W} 中的字符组成

思路

哈希表

代码

class Solution {
    public boolean isPathCrossing(String path) {
        HashMap<Integer, HashMap<Integer, Boolean>> map = new HashMap<>();
        int x = 0, y = 0;
        for (char ch: path.toCharArray()) {
            if (!map.containsKey(x)) {
                map.put(x, new HashMap<Integer, Boolean>());
            }
            map.get(x).put(y, true);
            switch(ch) {
                case 'N':
                    ++y;
                    break;
                case 'S':
                    --y;
                    break;
                case 'E':
                    ++x;
                    break;
                case 'W':
                    --x;
                    break;
            }
            if (map.containsKey(x) && map.get(x).containsKey(y)) {
                return true;
            }
        }
        return false;
    }
}

5449. 检查数组对是否可以被 k 整除

给你一个整数数组 arr 和一个整数 k ，其中数组长度是偶数，值为 n 。

现在需要把数组恰好分成 n / 2 对，以使每对数字的和都能够被 k 整除。

如果存在这样的分法，请返回 True ；否则，返回 False 。

示例 1：

输入：arr = [1,2,3,4,5,10,6,7,8,9], k = 5
输出：true
解释：划分后的数字对为 (1,9),(2,8),(3,7),(4,6) 以及 (5,10) 。
示例 2：

输入：arr = [1,2,3,4,5,6], k = 7
输出：true
解释：划分后的数字对为 (1,6),(2,5) 以及 (3,4) 。
示例 3：

输入：arr = [1,2,3,4,5,6], k = 10
输出：false
解释：无法在将数组中的数字分为三对的同时满足每对数字和能够被 10 整除的条件。
示例 4：

输入：arr = [-10,10], k = 2
输出：true
示例 5：

输入：arr = [-1,1,-2,2,-3,3,-4,4], k = 3
输出：true

提示：

arr.length == n
1 <= n <= 10^5
n 为偶数
-10^9 <= arr[i] <= 10^9
1 <= k <= 10^5

思路

统计mod k余数为0~(k-1)的个数，注意负数取模以及讨论k的奇偶性

代码

class Solution {
    public boolean canArrange(int[] arr, int k) {
        if (k == 1) {
            return true;
        }
        int n = arr.length, i = 0;
        int[] mods = new int[k];
        for (i=0; i<n; ++i) {
            arr[i] = arr[i] % k;
            if (arr[i] < 0) {
                arr[i] += k;
            }
            ++mods[arr[i]];
        }
        if (mods[0] % 2 != 0) {
            return false;
        }
        for (i=1; i<k/2; ++i) {
            if (mods[i] != mods[k-i]) {
                return false;
            }
        }
        if (k % 2 == 0) {
            if (mods[k/2] % 2 != 0) {
                return false;
            }
        } else {
            if (mods[k/2] != mods[k-k/2]) {
                return false;
            }
        }
        return true;
    }
}

5450. 满足条件的子序列数目

给你一个整数数组 nums 和一个整数 target 。

请你统计并返回 nums 中能满足其最小元素与最大元素的和小于或等于 target 的非空子序列的数目。

由于答案可能很大，请将结果对 10^9 + 7 取余后返回。

示例 1：

输入：nums = [3,5,6,7], target = 9
输出：4
解释：有 4 个子序列满足该条件。
[3] -> 最小元素 + 最大元素 <= target (3 + 3 <= 9)
[3,5] -> (3 + 5 <= 9)
[3,5,6] -> (3 + 6 <= 9)
[3,6] -> (3 + 6 <= 9)
示例 2：

输入：nums = [3,3,6,8], target = 10
输出：6
解释：有 6 个子序列满足该条件。（nums 中可以有重复数字）
[3] , [3] , [3,3], [3,6] , [3,6] , [3,3,6]
示例 3：

输入：nums = [2,3,3,4,6,7], target = 12
输出：61
解释：共有 63 个非空子序列，其中 2 个不满足条件（[6,7], [7]）
有效序列总数为（63 - 2 = 61）
示例 4：

输入：nums = [5,2,4,1,7,6,8], target = 16
输出：127
解释：所有非空子序列都满足条件 (2^7 - 1) = 127

提示：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6
1 <= target <= 10^6

思路

首先对数组排序。然后遍历排序后的数组，对于数组中的每一个元素cur，二分查找找到最后一个小于等于(target - cur)的元素right，统计包含cur并且可以包含或不包含(cur, target-cur]之间的元素的子序列个数。由于每个(cur, target-cur]之间的元素有取和不取两种选择，假设(cur, target-cur]之间的元素个数为k，则子序列个数为2^k. 这里涉及到一个乘方求模的运算。
乘方求模有一种对数复杂度的方法，基于如下事实：求a^b mod m，如果b为奇数，则a^b mod m = (a * a^(b-1)) mod m；如果b为偶数，则a^b mod m = (a^(b/2) * a^(b/2)) mod m. 可以写成递归形式，也可以写成循环形式，代码里使用了循环形式。
假设n = nums.length，一次二分查找的复杂度为O(logn), k的最大值是n，因此一次乘方求模的复杂度也是O(logn). 故总的算法时间复杂度为O(nlogn).
注意乘方求模方法涉及到乘法取模，很难控制乘法取模不超过int范围，因此乘方取模方法都用long类型。

代码

class Solution {
    private static final int mod = 1000000007;
    
    private int findRight(int[] nums, int target) {
        int n = nums.length, left = 0, right = n - 1, mid = 0;
        if (target < nums[0]) {
            return -1;
        } else if (target > nums[n-1]) {
            return n-1;
        }
        while (left <= right) {
            mid = (right - left) / 2 + left;
            if (nums[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return right;
    }
    
    private long multiMod(long a, long b, long m) {
        long ans = 1, tmp = a;
        while (b > 0) {
            if (b % 2 == 1) {
                ans = (ans * tmp) % m;
            }
            tmp = (tmp * tmp) % m;
            b /= 2;
        }
        return ans;
    }
    
    public int numSubseq(int[] nums, int target) {
        Arrays.sort(nums);
        int n = nums.length, i = 0, j = 0, r = 0;
        long ans = 0, cur = 0;
        for (i=0; i<n; ++i) {
            r = findRight(nums, target - nums[i]);
            if (r < n) {
                if (r >= i) {
                    cur = multiMod(2, r - i, mod);
                    ans = (ans + cur) % mod;
                }
            }
        }
        return (int)ans;
    }
}

5451. 满足不等式的最大值显示英文描述

给你一个数组 points 和一个整数 k 。数组中每个元素都表示二维平面上的点的坐标，并按照横坐标 x 的值从小到大排序。也就是说 points[i] = [xi, yi] ，并且在 1 <= i < j <= points.length 的前提下， xi < xj 总成立。

请你找出 yi + yj + |xi - xj| 的最大值，其中 |xi - xj| <= k 且 1 <= i < j <= points.length。

题目测试数据保证至少存在一对能够满足 |xi - xj| <= k 的点。

示例 1：

输入：points = [[0,0],[3,0],[9,2]], k = 3
输出：3
解释：只有前两个点满足 |xi - xj| <= 3 ，带入方程后得到值 0 + 0 + |0 - 3| = 3 。

提示：

2 <= points.length <= 10^5
points[i].length == 2
-10^8 <= points[i][0], points[i][1] <= 10^8
0 <= k <= 2 * 10^8
对于所有的1 <= i < j <= points.length ，points[i][0] < points[j][0] 都成立。也就是说，xi 是严格递增的。

思路

滑动窗口。注意到当i < j时，yi + yj + |xi - xj| = (yi - xi) + (xj + yj). 当xj遍历points数组时，滑动窗口使用优先队列维护所有满足xj - xi <= k的point并保持yi - xi最大的point始终位于队首。

代码

class Solution {
    class Point implements Comparable<Point> {
        public int diff, x;
        
        public Point(int diff, int x) {
            this.diff = diff;
            this.x = x;
        }
        
        @Override
        public int compareTo(Point other) {
            if (this.diff == other.diff) {
                return other.x - this.x;
            } else {
                return other.diff - this.diff;
            }
        }
    }
    
    public int findMaxValueOfEquation(int[][] points, int k) {
        int ans = Integer.MIN_VALUE, i = 0, n = points.length, j = 0;
        PriorityQueue<Point> pq = new PriorityQueue<>();
        for (int[] p: points) {
            while (!pq.isEmpty() && p[0] - pq.peek().x > k) {
                pq.poll();
            }
            if (!pq.isEmpty()) {
                ans = Math.max(ans, pq.peek().diff + p[0] + p[1]);
            }
            pq.offer(new Point(p[1] - p[0], p[0]));
        }
        return ans;
    }
}

da_kao_la

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode Weekly Contest 195

5448. 判断路径是否相交给你一个字符串 path，其中 path[i] 的值可以是 ‘N’、‘S’、‘E’ 或者 ‘W’，分别表示向北、向南、向东、向西移动一个单位。机器人从二维平面上的原点 (0, 0) 处开始出发，按 path 所指示的路径行走。如果路径在任何位置上出现相交的情况，也就是走到之前已经走过的位置，请返回 True ；否则，返回 False 。示例 1：输入：path = “NES”输出：false解释：该路径没有在任何位置相交。示例 2：输入：path = “NESW
复制链接

扫一扫