其实不用记录所有的异或值,直接维护最大值就行了。
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^2) O(n2)。
空间复杂度: O ( n ) O(n) O(n) -> O ( 1 ) O(1) O(1).
先按名字把所有访问记录给分出来,对每个人的访问时间排序,并判断是否有效。
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 ( n l o g n ) O(nlogn) O(nlogn)。
空间复杂度: O ( n ) O(n) O(n)。
首先,由于只能交换下标相同的数,因此,两个数组的两个最大值是固定的。
那么本质上只有两种情况: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 max2
for(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 max2
for(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(n) O(n)。
空间复杂度: O ( 1 ) O(1) O(1)。
从数据范围来看,暴力解的时间复杂度为 O ( n 2 ) O(n^2) O(n2),会超时。所以需要优化。比较容易的是想到用 map
来存已经出现过的数,但是由于数据范围较大,数的重复率较低,map
的作用不大,所以这里应该是 用 map
来存储出现过的前缀(见后文)。
1. 异或值
因为题目要求的是最大异或值,所以首先要关注 异或 的特性:
a ^ b = c
,则 a ^ c = c ^ a = b
,b ^ c = c ^ b = a
。所以,可以将数转换为二进制串来进行异或计算。同时,要想得到最大的异或值,那么应当 使结果从高位到低位尽量每一位都为 1 1 1 。
注意到数的大小为 [ 0 , 2 20 − 1 ] [0, 2^{20} - 1] [0,220−1],因此可以将所有的数转换为 20 20 20 位的二进制串。同时,得到的最大异或值也应当可以用 20 20 20 位的二进制串来表示。
而要使最大异或值最大,正如前面提到的一样,应当 使结果从高位到低位尽量每一位都为 1 1 1 。因此,从高位到低位,对于每一位,都假设最大异或值可以取到 1 1 1,然后去数组 nums[]
中寻查找,看能否成立。
2. 强数对
再看强数对的概念,对于强数对 ( x , y ) (x, y) (x,y),显然,若 x ≤ y x \leq y x≤y,则满足 x ≤ y ≤ 2 x x \leq y \leq 2x x≤y≤2x。因此,先对数组 nums[]
进行排序,从而简化后面的查找。
对于第 i i i 位能否为 1 1 1,最直接的办法是遍历所有的强数对,但这必然造成 O ( n 2 ) O(n^2) O(n2) 的复杂度,所以这里应当采用 map
来优化:假设当前遍历到数 n
,对于之前遍历过的 num
,将 num >> i
先保存在 map
(<前缀,原来的值>) 中,这样寻找只需花费 O ( 1 ) O(1) O(1) 的时间复杂度,由于数组 nums[]
是有序的,所以必然能够保证 n ≥ n u m n \geq num n≥num,因此,这里只需要判断 n ≤ 2 ∗ n u m n \leq 2 * num n≤2∗num 即可。
这样的话,对于每一位,只要遍历一遍数组 nums[]
即可,同时在遍历数组 nums[]
的同时,更新 map
,以及判断是否可以使最大异或值的当前位为 1 1 1,若可以为 1 1 1 则可以提前结束当前位的遍历。因此,时间复杂度为 O ( n l o g C ) O(n logC) O(nlogC),其中,C 为数组 nums[]
中最大值的二进制位数。
误区:
之前一直在纠结 map
的存储方式,如果以 <前缀,原来的值> 来存储的话,那么会导致相同前缀的 num
被 覆盖,这不会导致部分强数对被遗漏没有遍历到吗(求最值必然要遍历所有值)?
nums[]
有序),因此,更容易使 n ≤ 2 ∗ n u m n \leq 2 * num n≤2∗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 ( n l o g n + n l o g C ) O(nlogn + n logC) O(nlogn+nlogC)。 O ( n l o g n ) O(nlogn) O(nlogn) 是排序的时间。其中,C 为数组 nums[]
中最大值的二进制位数。
空间复杂度: O ( n ) O(n) O(n),map
的空间,最坏情况,没有重复的数,那么在 k = 0
时,所有的数都会被存储到 map
中。
同样是将数转换为二进制串来优化时间。
注意:字典树的根节点没有意义。
struct Trie{
Trie* left = nullptr; // 0
Trie* right = nullptr; // 1
int 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;
else
cur = 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 ( n l o g n + n l o g C ) O(nlogn + nlogC) O(nlogn+nlogC)。 O ( n l o g n ) O(nlogn) O(nlogn) 是排序的时间。其中,C 为数组 nums[]
中最大值的二进制位数。
空间复杂度: O ( n l o g C ) O(nlogC) O(nlogC),map
的空间,最坏情况,没有重复的数,那么在 k = 0
时,所有的数都会被存储到 map
中。