【LeetCode 】周赛（2023.11.12）

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;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

复杂度

时间复杂度：$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;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

复杂度

时间复杂度：$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 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);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

复杂度

时间复杂度：$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;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

复杂度

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

解法2 0-1 Trie / 字典树

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

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

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;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

复杂度

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

---