【LeetCode双周赛】第 113 场双周赛
LeetCode第 113 场双周赛
- 使数组成为递增数组的最少右移次数 简单
- 删除数对后的最小数组长度 中等
- 统计距离为 k 的点对 中等
使数组成为递增数组的最少右移次数 简单
给你一个长度为 n 下标从 0 开始的数组 nums ，数组中的元素为 互不相同 的正整数。请你返回让 nums 成为递增数组的 最少右移 次数，如果无法得到递增数组，返回 -1 。
一次 右移 指的是同时对所有下标进行操作，将下标为 i 的元素移动到下标 (i + 1) % n 处。
示例 1：
输入：nums = [3,4,5,1,2]
输出：2
解释：
第一次右移后，nums = [2,3,4,5,1] 。
第二次右移后，nums = [1,2,3,4,5] 。
现在 nums 是递增数组了，所以答案为 2 。
示例 2：
输入：nums = [1,3,5]
输出：0
解释：nums 已经是递增数组了，所以答案为 0 。
示例 3：
输入：nums = [2,1,4]
输出：-1
解释：无法将数组变为递增数组。
提示：
- 1 <= nums.length <= 100
- 1 <= nums[i] <= 100
- nums 中的整数互不相同。
分析： 简单题，找到最小值的位置i，判断0 ~ i-1以及i ~ nums.length-1均为递增，且nums[nums.length -1] < nums[0]。
可以利用%将两个部分连接起来，判断一整个数组是否递增。
代码：
class Solution {
public:
int minimumRightShifts(vector<int>& nums) {
int m = 101,index;
for(int i=0;i<nums.size();i++){
if(m>nums[i]){index=i;m=nums[i];}
}
for(int j=index+1;;j++){
if(j==index+nums.size()) break;
if(nums[j%nums.size()]<nums[(j-1)%nums.size()]){
return -1;
}
}
return (nums.size() - index)%nums.size();
}
};
删除数对后的最小数组长度 中等
给你一个下标从 0 开始的 非递减 整数数组 nums 。
你可以执行以下操作任意次：
选择 两个 下标 i 和 j ，满足 i < j 且 nums[i] < nums[j] 。
将 nums 中下标在 i 和 j 处的元素删除。剩余元素按照原来的顺序组成新的数组，下标也重新从 0 开始编号。
请你返回一个整数，表示执行以上操作任意次后（可以执行 0 次），nums 数组的 最小 数组长度。
示例 1：
输入：nums = [1,3,4,9]
输出：0
解释：一开始，nums = [1, 3, 4, 9] 。
第一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 1 < 3 。
删除下标 0 和 1 处的元素，nums 变成 [4, 9] 。
下一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 4 < 9 。
删除下标 0 和 1 处的元素，nums 变成空数组 [] 。
所以，可以得到的最小数组长度为 0 。
示例 2：
输入：nums = [2,3,6,9]
输出：0
解释：一开始，nums = [2, 3, 6, 9] 。
第一次操作，我们选择下标 0 和 2 ，满足 nums[0] < nums[2] <=> 2 < 6 。
删除下标 0 和 2 处的元素，nums 变成 [3, 9] 。
下一次操作，我们选择下标 0 和 1 ，满足 nums[0] < nums[1] <=> 3 < 9 。
删除下标 0 和 1 处的元素，nums 变成空数组 [] 。
所以，可以得到的最小数组长度为 0 。
示例 3：
输入：nums = [1,1,2]
输出：1
解释：一开始，nums = [1, 1, 2] 。
第一次操作，我们选择下标 0 和 2 ，满足 nums[0] < nums[2] <=> 1 < 2 。
删除下标 0 和 2 处的元素，nums 变成 [1] 。
无法对数组再执行操作。
所以，可以得到的最小数组长度为 1 。
提示：
- 1 <= nums.length <= 10^5
- 1 <= nums[i] <= 10^9
- nums 是 非递减 数组。
分析： 思维题。竞赛时没写出来！
竞赛时的错误思考：
- 最大和最小值进行消除，样例：[1,2,2,2,3]判断错误。
- 出现数字最多的和第二多的完全消除，以此类推，样例：[1,1,2,2,3,3]判断错误
- 出现数字最多的和第二多的消除一个，然后再重新排序，再消除，超时
最终正确答案的分析：
数组本身是非递减的，如果某个数更大，那么其索引也更大。
统计出现次数最多的数，即众数，其出现次数为max_cnt，分三种情况：
- 如果
max_cnt * 2 > nums.length，最终剩余数的个数为：max_cnt * 2 - nums.length - 如果
max_cnt * 2 < nums.length, 且nums.length为偶数，那么可以将其他数消除至max_cnt，再完全消除 - 如果
max_cnt * 2 < nums.length, 且nums.length为奇数，也可以将其他数消除，但最终会多一个数。
代码：
class Solution {
public:
int minLengthAfterRemovals(vector<int>& nums) {
int l = nums.size();
int x = nums[l/2];
int max_num = upper_bound(nums.begin(), nums.end(), x) - lower_bound(nums.begin(), nums.end(), x);
return max(max_num*2-l, l%2);
}
};
统计距离为 k 的点对 中等
给你一个 二维 整数数组 coordinates 和一个整数 k ，其中 coordinates[i] = [xi, yi] 是第 i 个点在二维平面里的坐标。
我们定义两个点 (x1, y1) 和 (x2, y2) 的 距离 为 (x1 XOR x2) + (y1 XOR y2) ，XOR 指的是按位异或运算。
请你返回满足 i < j 且点 i 和点 j之间距离为 k 的点对数目。
示例 1：
输入：coordinates = [[1,2],[4,2],[1,3],[5,2]], k = 5
输出：2
解释：以下点对距离为 k ：
- (0, 1)：(1 XOR 4) + (2 XOR 2) = 5 。
- (2, 3)：(1 XOR 5) + (3 XOR 2) = 5 。
示例 2：
输入：coordinates = [[1,3],[1,3],[1,3],[1,3],[1,3]], k = 0
输出：10
解释：任何两个点之间的距离都为 0 ，所以总共有 10 组点对。
提示：
2 <= coordinates.length <= 500000 <= xi, yi <= 10^60 <= k <= 100
分析：
对于异或运算存在一个定理：
a ⊕ b = c < = = > a ⊕ c = b a ⊕ b = c <==> a ⊕ c = b a⊕b=c<==>a⊕c=b
因此对于(x1 XOR x2) + (y1 XOR y2) = k，假设(x1 XOR x2) = i，那么(y1 XOR y2) = k-i
同时，因为定理，因此(i XOR x1) = x2，那么((k-i) XOR y1) = y2，因此直接进行计算。
同时要注意i < j的情况。
代码 ：
class Solution {
public:
int countPairs(vector<vector<int>>& coordinates, int k) {
unordered_map<long long, int> m;
int ans=0;
for(auto& coordinate : coordinates){
for(int i=0;i<=k;i++){
long long key=(coordinate[0]^i) * 1000000LL + (coordinate[1]^(k-i));
auto value = m.find(key);
if(value != m.end()) ans += value->second;
}
m[(coordinate[0]) * 1000000LL + (coordinate[1])]++;
}
return ans;
}
};