2932. 找出强数对的最大异或值 I

题意

• 找出强数对的最大异或值

解法 暴力

其实不用记录所有的异或值，直接维护最大值就行了。

class Solution {
public:int maximumStrongPairXor(vector<int>& nums) {unordered_map<int, int> mp;int n = nums.size();for(int i = 0; i < n; i++){for(int j = i + 1; j < n; j++){if(abs(nums[i] - nums[j]) <= min(nums[i], nums[j])){int tmp = nums[i] ^ nums[j];mp[tmp]++;}}}int ans = 0;for(auto m : mp){if(m.first > ans){ans = m.first;}}return ans;}
};

复杂度

时间复杂度：$O(n^2)$。
空间复杂度：$O(n)$ -> $O(1)$.

---

2933. 高访问员工

题意

• 字符串处理
• 计算每个员工的有效访问次数

解法 按名字排序时间再筛选

先按名字把所有访问记录给分出来，对每个人的访问时间排序，并判断是否有效。

class Solution {
public:vector<string> findHighAccessEmployees(vector<vector<string>>& access_times) {vector<string> ans;unordered_map<string, vector<string>> mp; for(auto v : access_times){mp[v[0]].push_back(v[1]);}for(auto m : mp){string name = m.first;vector<string> tmp = m.second;if(tmp.size() < 3) continue;sort(tmp.begin(), tmp.end());for(int i = 0; i < tmp.size() - 2; i++){int st = stoi(tmp[i].substr(0, 2)) * 60 + stoi(tmp[i].substr(2, 2));int ed = stoi(tmp[i + 2].substr(0, 2)) * 60 + stoi(tmp[i + 2].substr(2, 2));if(ed - st < 60){ans.push_back(name);break;}}}return ans;}
};

复杂度

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

---

100117. 最大化数组末位元素的最少操作次数

题意

• 每次可以互换两个数组中下标相同的数
• 求最少操作次数，使得数组最后一个数大于数组中其他所有数

解法 分类讨论

首先，由于只能交换下标相同的数，因此，两个数组的两个最大值是固定的。

那么本质上只有两种情况：nums1[n - 1] 和 nums2[n - 1] 交换或者不交换。

只要确定了数组的最大值，就可以开始交换了。假设 nums1 的最大值为 max1，nums2 的最大值为 max2。遍历所有下标，比较 nums1[i] 、nums2[i]、max1 以及 nums2，分类讨论即可。

class Solution {
public:int minOperations(vector<int>& nums1, vector<int>& nums2) {int n = nums1.size();int max1 = nums1[n - 1], max2 = nums2[n - 1];int ans = 0;// 不交换 max1 max2for(int i = 0; i < n - 1; i++){if(nums1[i] <= max1 && nums2[i] <= max2) continue;else if(nums1[i] <= max2 && nums2[i] <= max1){ans++;continue;}else{ans = -1;break;}}int ans2 = 1;// 交换 max1 max2for(int i = 0; i < n - 1; i++){if(nums1[i] <= max2 && nums2[i] <= max1) continue;else if(nums1[i] <= max1 && nums2[i] <= max2){ans2++;continue;}else{ans2 = -1;break;}}if(ans == -1 && ans2 == -1) return -1;if(ans == -1) return ans2;if(ans2 == -1) return ans;return min(ans, ans2);}
};

复杂度

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

---

100124. 找出强数对的最大异或值 II

题意

• 在强数对中寻找最大异或值。

解法1 哈希表 + 二进制串转换 + 贪心

从数据范围来看，暴力解的时间复杂度为 $O(n^2)$，会超时。所以需要优化。比较容易的是想到用 map 来存已经出现过的数，但是由于数据范围较大，数的重复率较低，map 的作用不大，所以这里应该是 用 map 来存储出现过的前缀（见后文）。

1. 异或值
因为题目要求的是最大异或值，所以首先要关注 异或 的特性：

• 异或是一种位运算，所以 位与位独立。
• 若 a ^ b = c，则 a ^ c = c ^ a = b，b ^ c = c ^ b = a。

所以，可以将数转换为二进制串来进行异或计算。同时，要想得到最大的异或值，那么应当 使结果从高位到低位尽量每一位都为 $1$ 。

注意到数的大小为 $[0,2^{20}-1]$，因此可以将所有的数转换为 $20$ 位的二进制串。同时，得到的最大异或值也应当可以用 $20$ 位的二进制串来表示。

而要使最大异或值最大，正如前面提到的一样，应当 使结果从高位到低位尽量每一位都为 $1$ 。因此，从高位到低位，对于每一位，都假设最大异或值可以取到 $1$，然后去数组 nums[] 中寻查找，看能否成立。

2. 强数对
再看强数对的概念，对于强数对 $(x,y)$，显然，若 $x\le y$，则满足 $x\le y\le 2x$。因此，先对数组 nums[] 进行排序，从而简化后面的查找。

对于第 $i$ 位能否为 $1$，最直接的办法是遍历所有的强数对，但这必然造成 $O(n^2)$ 的复杂度，所以这里应当采用 map 来优化：假设当前遍历到数 n，对于之前遍历过的 num，将 num >> i 先保存在 map（<前缀，原来的值>） 中，这样寻找只需花费 $O(1)$ 的时间复杂度，由于数组 nums[] 是有序的，所以必然能够保证 $n\ge num$，因此，这里只需要判断 $n\le 2\ast num$ 即可。

这样的话，对于每一位，只要遍历一遍数组 nums[] 即可，同时在遍历数组 nums[] 的同时，更新 map，以及判断是否可以使最大异或值的当前位为 $1$，若可以为 $1$ 则可以提前结束当前位的遍历。因此，时间复杂度为 $O(nlogC)$，其中，C 为数组 nums[] 中最大值的二进制位数。

误区：
之前一直在纠结 map 的存储方式，如果以 <前缀，原来的值> 来存储的话，那么会导致相同前缀的 num 被 覆盖，这不会导致部分强数对被遗漏没有遍历到吗（求最值必然要遍历所有值）？

• 答案是会的。但是没有影响。 对于第 $i$ 位能否为 $1$，只需要数的前 $i$ 位做运算即可（本质上只需要第 $i$ 位，但是前面的位的值已经决定了，所以要在满足前 $i-1$ 为的前提下来判断第 $i$ 位）。所以，即便之前的 $num$ 被覆盖了，他也不会影响前 $i$ 位的异或值。同时，由于覆盖之前 $num$ 的 $nu{m}^{\prime }$ 必然大于等于 $num$（数组 nums[] 有序），因此，更容易使 $n\le 2\ast num$ 这个条件满足。

class Solution {
private:static const int HIGH_BIT = 19;
public:int maximumStrongPairXor(vector<int>& nums) {int n = nums.size();int x = 0;sort(nums.begin(), nums.end());for(int k = HIGH_BIT; k >= 0; k--){unordered_map<int, int> mp;int x_next = x * 2 + 1;bool found = false;for(int n : nums){mp[n >> k] = n;    if(mp.count(x_next ^ (n >> k)) && mp[x_next ^ (n >> k)] * 2 >= n){found = true;break;}  }if(found) x = x_next;else x = x_next - 1;}return x;}
};

复杂度

时间复杂度： $O(nlogn+nlogC)$。$O(nlogn)$ 是排序的时间。其中，C 为数组 nums[] 中最大值的二进制位数。
空间复杂度：$O(n)$，map 的空间，最坏情况，没有重复的数，那么在 k = 0 时，所有的数都会被存储到 map 中。

解法2 0-1 Trie / 字典树

同样是将数转换为二进制串来优化时间。

注意：字典树的根节点没有意义。

struct Trie{Trie* left = nullptr;   // 0Trie* right = nullptr;  // 1int cnt = 0;    // 他的孩子数 或者说 经过它的字符串的数量Trie() {};
};class Solution {
private:static const int high_bit = 19;Trie* root = new Trie();public:void insertNum(int num){Trie* cur = root;for(int k = high_bit; k >= 0; k--){int bit = (num >> k) & 1;if(bit == 0)    // 当前位 只与 cur的孩子 有关系{if(!cur->left){cur->left = new Trie();}cur = cur->left;}else{if(!cur->right){cur->right = new Trie();}cur = cur->right;}cur->cnt++;     // 孩子++}}void deleteNum(int num){Trie* cur = root;for(int k = high_bit; k >= 0; k--){int bit = (num >> k) & 1;if(bit == 0)cur = cur->left;elsecur = cur->right;cur->cnt--;}}int calXor(int num){Trie* cur = root;int tmp = 0;int x = 0;for(int k = high_bit; k >= 0; k--){int bit = (num >> k) & 1;if(bit == 0){if(cur->right && cur->right->cnt > 0)   // 右孩子存在{cur = cur->right;x = x * 2 + 1;}else if(cur->left && cur->left->cnt > 0)    // 左孩子存在{cur = cur->left;x = x * 2;}}else{if(cur->left && cur->left->cnt > 0){cur = cur->left;x = x * 2 + 1;}else if(cur->right && cur->right->cnt > 0){cur = cur->right;x = x * 2;}}}return x;}int maximumStrongPairXor(vector<int>& nums) {int n = nums.size();sort(nums.begin(), nums.end());int l = 0, r = 0;int ans = 0;while(l < n)   // [l, r){if(r < n && nums[r] <= nums[l] * 2){insertNum(nums[r]);ans = max(ans, calXor(nums[r]));r++;}else if(r < n && nums[r] > nums[l] * 2){deleteNum(nums[l]);l++;}else if(r == n){deleteNum(nums[l]);l++;}}return ans;}
};

复杂度

时间复杂度： $O(nlogn+nlogC)$。$O(nlogn)$ 是排序的时间。其中，C 为数组 nums[] 中最大值的二进制位数。
空间复杂度：$O(nlogC)$，map 的空间，最坏情况，没有重复的数，那么在 k = 0 时，所有的数都会被存储到 map 中。

---