题目描述

有 $N$ 种食材，编号从 $0$ 至 $N-1$，其中第 $i$ 种食材的美味度为 $a_i$。

不同食材之间的组合可能产生奇妙的化学反应。具体来说，如果两种食材的美味度分别为 $x$ 和 $y$ ，那么它们的契合度为 $x\ \text{and}\ y $。

其中，$\text{and}$ 运算为按位与运算，需要先将两个运算数转换为二进制，然后在高位补足 ，再逐位进行与运算。例如，$12$ 与 $6$ 的二进制表示分别为 $1100$ 和 $0110$ ，将它们逐位进行与运算，得到 $0100$ ，转换为十进制得到 4，因此 $12\text{ and }6=4$。在 C++ 或 Python 中，可以直接使用 & 运算符表示与运算。

现在，请你找到契合度最高的两种食材，并输出它们的契合度。

输入格式

第一行一个整数 $N$，表示食材的种数。

接下来一行 $N$ 个用空格隔开的整数，依次为 $a_1,\cdots ,a_N$，表示各种食材的美味度。

输出格式

输出一行一个整数，表示最高的契合度。

输入输出样例 #1

输入 #1

3
1 2 3

输出 #1

2

输入输出样例 #2

输入 #2

5
5 6 2 10 13

输出 #2

8

说明/提示

样例解释 1

可以编号为 $1,2$ 的食材之间的契合度为 $2\text{and}3=2$，是所有食材两两之间最高的契合度。

样例解释 2

可以编号为 $3,4$ 的食材之间的契合度为 $10\text{and}13=8$，是所有食材两两之间最高的契合度。

数据范围

对于 $40\%$ 的测试点，保证 $N\le 1,000$；

对于所有测试点，保证 $N\le 10^6$，$0\le a_i\le 2,147,483,647$。

提交链接

烹饪问题

思路分析

对于 $40\%$ 的测试点：

❌ 暴力算法（$100\%$ 的数据会超时）

枚举所有 $(i,j)$ 组合，复杂度 $O(N^2)$，在 $n=10^6$ 时会超时

#include <bits/stdc++.h>
using namespace std;int n, a[1000009];int main()
{cin >> n;for (int i = 1; i <= n; i++)cin >> a[i];int mx_and = 0;for (int i = 1; i <= n; i++)for (int j = i + 1; j <= n; j++)mx_and = max(mx_and, a[i] & a[j]);cout << mx_and;return 0;
}

对于 $100\%$ 的测试点：

思路1：

AND 运算结果的大与小由高位决定：高位为 $1$ 越多，结果越大。我们从高位往低位贪心，希望两个数在高位尽可能都为 $1$。

我们可以：

1. 遍历 $31\sim 0$ 位（因为数据范围不超过 $2^{31}-1$）

2. 每次筛出当前位为 $1$ 的数集合

3. 如果这集合里数量 $\ge 2$，就只保留它们继续往低位考虑

4. 最终从这些数中找一组最大 AND 值

主逻辑

int mx_and = 0;
for(int pos = 31; pos >= 0; pos--) {int num = check_and(1, n, pos);if(num >= 2) {mx_and |= (1 << pos);n = num;}
}

从最高位 $31$ 递减到最低位 $0$，逐位处理：for(int pos = 31; pos >= 0; pos--)

每次调用 check_and 将数组按照该位是否为 $1$ 重新划分：int num = check_and(1, n, pos);

如果划分后，第 $pos$ 位为 $1$ 的数不少于 $2$ 个，则将该位保留在答案中，同时更新数组范围只保留这部分数，继续判断下一位，如果不足两个数，则该位不能保留。

if(num >= 2) 
{mx_and |= (1 << pos);n = num;
}

关键函数解析：check_and

int check_and(int l, int r, int bit) 
{int i = l, j = r;while (i <= j) {// 左指针跳过第 bit 位为 1 的数while (i <= j && ((a[i] >> bit) & 1)) i++;// 右指针跳过第 bit 位为 0 的数while (i <= j && !((a[j] >> bit) & 1)) j--;if (i < j) swap(a[i++], a[j--]);}return j;
}

该函数将数组 $[l..r]$ 中的元素根据第 $bit$ 位分为两部分：

• 左半部分是第 $bit$ 位为 $1$ 的数。

• 右半部分是第 $bit$ 位为 $0$ 的数。

返回值 $j$ 表示第 $bit$ 位为 $1$ 的数所在区间的最后一个位置。

完整代码

#include<bits/stdc++.h>
using namespace std;int n , a[1000009];int check_and(int i , int j , int bit)
{while(i <= j){while(i <= j && a[i] >> bit & 1) i++;while(i <= j && !(a[j] >> bit & 1))j--;if(i <= j)	swap(a[i++] , a[j--]);}return j;
}
int main()
{cin >> n;for(int i = 1; i <= n; i++)cin >> a[i];int mx_and = 0;for(int pos = 31; pos >= 0; pos--){int num = check_and(1 , n , pos);if(num >= 2){mx_and |= 1 << pos;n = num;}}cout << mx_and;return 0;
}

思路2：

从数组中取出最大的 $32$ 个数，然后在它们之间暴力两两组合，求最大 a[i] & a[j]

1. AND 的值由高位影响最大

   因为 AND 运算中，只有两个数该位都是 $1$，结果才是 $1$，所以想让结果最大，就要让两个数在高位尽量都是 $1$。高位相同的数才更容易 AND 出更大的数。

2. 越大的数，高位 $1$ 越可能多

   数值大的数，二进制中左侧（高位）出现 $1$ 的概率更高，所以最大 AND 通常出现在“比较大的两个数”之间。

3. 最多 $32$ 个不同高位组合

   因为 $int$ 是 $32$ 位，最多有 $32$ 个不同的“最高位为 $1$”的模式，所以只取最大 $32$ 个数，就等于把每一种高位代表的结构都涵盖了。

参考代码

#include<bits/stdc++.h>
using namespace std;int n , a[1000009];int main()
{cin >> n;for(int i = 1; i <= n; i++)cin >> a[i];sort(a + 1 , a + n + 1 , greater<int>());n = min(n , 32);int mx_and = 0;for(int i = 1; i <= n; i++)for(int j = i + 1; j <= n; j++)mx_and = max(mx_and , a[i] & a[j]);cout << mx_and;return 0;
}