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 = [[1,3],[2,0],[5,10],[6,-10]], k = 1
輸出：4
解釋：前兩個點滿足 |xi - xj| <= 1 ，帶入方程計算，則得到值 3 + 0 + |1 - 2| = 4 。第三個和第四個點也滿足條件，得到值 10 + -10 + |5 - 6| = 1 。
沒有其他滿足條件的點，所以返回 4 和 1 中最大的那個。
示例 2：
輸入：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;
}
}