给定一个长度为 n n 的数列 a i a i ​ ，求 a i a i ​ 的子序列 b i b i ​ 的最长长度 k k，满足 b i & b i − 1 ≠ 0 b i ​ &b i−1 ​  =0，其中 2 ≤ i ≤ k 2≤i≤k， & & 表示位运算取与。 输入格式 输入文件共 2 2 行。 第一行包括一个整数 n n。 第二行包括 n n 个整数，第 i i 个整数表示 a i a i ​ 。 输出格式 输出文件共一行。 包括一个整数，表示子序列 b i b i ​ 的最长长度。 输入数据 1 3 1 2 3 输出数据 1 2 提示 对于 100 % 100% 的数据， 1 ≤ n ≤ 100000 1≤n≤100000， a i ≤ 1 0 9 a i ​ ≤10 9 。用c++代码解决

<think>题目要求：给定一个数列，求最长子序列的长度，使得子序列中相邻两个元素的按位与不为0（即b[i]&b[i-1]!=0）。思路：我们使用动态规划来解决。设dp[i]表示以第i个元素结尾的最长子序列的长度（满足相邻元素按位与不为0）。状态转移方程：对于位置i，我们考虑前面的所有位置j（0<=j<i），如果a[i]和a[j]的按位与不为0，则dp[i]=max(dp[i],dp[j]+1)。但是，n最大为100000，如果双重循环（O(n^2)）会超时。因此，我们需要优化动态规划过程。考虑按位与的性质：如果a[i]和a[j]的按位与不为0，那么它们至少有一个二进制位同时为1。我们可以这样优化：对于当前元素a[i]，我们考虑它的每一个二进制位（最多31位），然后我们想要知道在a[i]之前，某个二进制位为1的位置上，最长的子序列长度是多少。具体做法：设dp[i]表示以第i个元素结尾的最长子序列长度。另外，我们用一个辅助数组max_bit，其中max_bit[k]表示遍历到当前位置时，在第k个二进制位上为1的元素结尾的子序列的最大长度。那么，状态转移可以这样：对于当前元素a[i]，我们遍历它的所有二进制位（0到31位），如果a[i]的第k位为1，那么所有之前在第k位为1的元素都可以和a[i]相邻（因为这一位按位与肯定非0）。因此，我们可以从这些位置转移。即：dp[i]=max(dp[i],max_bit[k]+1)[对于所有a[i]的第k位为1的二进制位]但是注意，我们可能从多个二进制位得到不同的max_bit[k]值，那么dp[i]应该是所有能转移的位中最大的那个+1（因为只要求相邻两个元素的按位与非0即可，并不需要所有位都相同，所以我们可以取所有可能转移的最大值）。然后，在更新完dp[i]后，我们还需要更新max_bit数组：对于a[i]的每一位为1的二进制位k，我们令max_bit[k]=max(max_bit[k],dp[i])。初始化：dp[0]=1（第一个元素自己组成长度为1的序列），同时，由于第一个元素有若干二进制位，那么对于这些二进制位k，max_bit[k]=max(max_bit[k],1)。注意：max_bit数组初始化时，全部置为0。这样，我们就在O(n*32)的时间复杂度内解决了问题，因为每个数最多32位（因为a[i]<=10^9，所以31位足够）。算法步骤：1.读入n和数组a。2.初始化dp数组，长度为n，dp[0]=1。3.初始化max_bit数组，长度为32（0到31位），全部为0。4.对于第一个元素a[0]，我们将其二进制位为1的位置k，设置max_bit[k]=1（实际上就是更新max_bit[k]=max(max_bit[k],1)）。5.从i=1到n-1遍历：dp[i]=1（至少长度为1）对于每一位k（0到31）：如果a[i]的第k位为1，那么我们可以从max_bit[k]得到转移：dp[i]=max(dp[i],max_bit[k]+1)然后，对于每一位k（0到31）：如果a[i]的第k位为1，则更新max_bit[k]=max(max_bit[k],dp[i])6.遍历dp数组，求出最大值，即为答案。但是注意：我们并不需要每次都遍历32位，可以通过一个循环来遍历每一位，也可以使用位运算技巧。然而，还有一种情况：我们可能会从当前元素的多个二进制位得到不同的max_bit值，所以我们需要先遍历所有位，找出所有满足条件的max_bit值中的最大值，然后再更新dp[i]。例子：输入[1,2,3]1:二进制1->第0位为1。dp[0]=1，更新max_bit[0]=1。2:二进制10->第1位为1。对于第1位，max_bit[1]当前为0，所以dp[1]=max(1,0+1)=1->但注意，我们可能需要考虑所有的位，但这里只有一位，所以dp[1]=1。然后更新max_bit[1]=max(max_bit[1],1)->1。3:二进制11->第0位和第1位都为1。对于第0位：max_bit[0]=1->可以转移：1+1=2对于第1位：max_bit[1]=1->也可以转移：1+1=2所以dp[2]=max(1,2)=2然后更新第0位和第1位的max_bit：max_bit[0]=max(1,2)=2;max_bit[1]=max(1,2)=2。因此，最后max(dp)=2，输出2，正确。代码实现：重要：遍历每一位k（0到31），判断a[i]的第k位是否为1：可以用(a[i]>>k)&1来判断。注意：我们要求的是子序列（不一定连续），但我们的动态规划是考虑前面所有满足条件的数。代码：我们不必为每一个数都遍历所有32位，因为32是常数，所以时间复杂度O(32*n)是可行的（100000*32=3.2e6，在C++中是可以接受的）。步骤：读入n和数组a。初始化dp数组（长度n），dp[0]初始为1。初始化一个长度为32的数组max_bit，所有元素为0。然后，对于第一个元素a[0]，我们遍历k从0到31，如果a[0]的第k位为1，那么max_bit[k]=max(max_bit[k],1)->实际上就是1，因为原来0和1取大就是1。然后从i=1到n-1：初始化当前dp[i]=1（最小值）然后遍历0到31的每一位k：如果(a[i]的第k位为1)&&(max_bit[k]不为0)[注意：这里max_bit[k]不为0并不是必须的，因为如果为0，那么0+1=1，与初始值一样，所以也可以不加判断]那么：dp[i]=max(dp[i],max_bit[k]+1)然后，再遍历0到31的每一位k：如果a[i]的第k位为1：max_bit[k]=max(max_bit[k],dp[i])最后，遍历dp数组，找到最大值输出。但是，上面的状态转移中，我们并没有利用到之前多个位的信息：实际上，我们对于当前元素a[i]，从所有为1的位中取max_bit的最大值？不对，上面的代码是逐个位比较，然后取最大值。但实际上我们应该是：对于当前元素a[i]，我们看它在哪些位上是1，然后这些位上的max_bit值我们都可以利用，所以我们要求的是这些位中max_bit的最大值，然后+1。修改：我们可以先把当前元素a[i]的所有为1的位的max_bit值取一个最大值，然后+1作为dp[i]。所以：dp[i]=1;forkin0..31:if(a[i]>>k)&1:dp[i]=max(dp[i],max_bit[k]+1)#这个转移实际上对于每一个位都加了1，然后取最大，但这样得到的是所有位中最大转移值，正确。另一种做法：我们用一个临时变量max_val=1，然后对于每个位k，如果第k位为1，那么max_val=max(max_val,max_bit[k]+1)。这样是可以的。但是，还有一种情况：如果a[i]在多个位上为1，那么它可以从这些位中的任何一个位对应的最大值转移过来。所以这样写没有问题。代码：注意：不要忘记更新max_bit数组：对于每个为1的位，都要更新max_bit[k]为当前dp[i]和原max_bit[k]的较大值。我们这样写：for(inti=1;i< n;i++){dp[i]=1;//至少为1//遍历32位for(intk=0;k<32;k++){if(a[i]&(1LL<< k)){//这里要注意，如果数字很大，左移31位可能导致整数溢出？所以用1LL，但题目a[i]<=10^9，31位不会溢出。也可以用unsigned？//但是，我们也可以这样写：if((a[i]>>k)&1)if(max_bit[k]!=0){//实际上，我们不需要判断0，因为0+1也等于1，而初始dp[i]=1，所以可以省去dp[i]=max(dp[i],max_bit[k]+1);}}}//更新max_bitfor(intk=0;k<32;k++){if(a[i]&(1<< k)){//同样，这里也要判断位，但是注意：如果a[i]特别大，超过int，但题目10^9在int范围内（int一般32位，可表示到2e9多），所以用int即可，或者用longlong来移位？max_bit[k]=max(max_bit[k],dp[i]);}}}但是要注意：如果a[i]很大，第31位，1<<31在int上可能是负数（因为符号位），所以最好用unsignedint或者longlong，或者用1LL<<k，但是题目说a[i]<=10^9，所以k最大30（10^9<2^30约为1e9，2^30=1e9多，所以k最多到30）。实际上，31位就可以了，因为2^31=2e9>10^9，所以k=0到31位。但是，为了安全，我们使用32位，并且用longlong类型的位运算（或者无符号整数）。但是题目说a[i]<=10^9，所以用32位整数也可以。然而，在C++中，1<<k：当k>=32时，左移32位对于int是未定义行为，但我们的k在0~31，所以安全。但是，使用1<<k，如果k=31，对于32位有符号整数，1<<31会变成负数，而a[i]是正数，按位与不会得到1，因此不会进入循环。为了避免负数情况，我们使用无符号整数移位，或者用(1LL<<k)。建议：使用1LL<<k。或者，使用(a[i]>>k)&1的方式判断第k位。为了简单和可移植性，我们使用(a[i]>>k)&1的方式。修改：for(inti=1;i< n;i++){dp[i]=1;for(intk=0;k<32;k++){if((a[i]>>k)&1){//判断第k位是否为1if(max_bit[k]){//如果max_bit[k]不为0，则更新。但是不为0也可以加1？因为max_bit[k]至少为0，所以max_bit[k]+1>=1，而dp[i]初始为1，所以其实不加这个if也可以，因为不影响结果（加了可能避免一次加法？）dp[i]=max(dp[i],max_bit[k]+1);}}}for(intk=0;k<32;k++){if((a[i]>>k)&1){max_bit[k]=max(max_bit[k],dp[i]);}}}实际上，max_bit[k]初始化为0，在第一次更新前都是0，而0+1=1，所以与dp[i]初始值相同，所以可以去掉内层if判断：for(inti=1;i< n;i++){dp[i]=1;for(intk=0;k<32;k++){if((a[i]>>k)&1){dp[i]=max(dp[i],max_bit[k]+1);}}for(intk=0;k<32;k++){if((a[i]>>k)&1){max_bit[k]=max(max_bit[k],dp[i]);}}}这样写是没问题的。注意：我们不需要担心max_bit[k]还没被更新过，因为0+1=1，而dp[i]初始就是1，所以不影响。最后，我们遍历dp数组，求最大值输出。但是，我们也可以不用dp数组，用一个变量ans来记录全局最大值，在每次更新dp[i]时更新ans。完整代码：注意：n的范围是100000，所以我们需要定义数组a[100010]，dp[100010]（其实dp可以不用数组，因为每次只用到当前值，但为了最后求最大值，我们保留数组。也可以用一个变量记录最大值）。代码：由于32*n=3.2e6，在C++中跑100000个数的32倍是3.2e6，是可行的。但是，我们也可以优化内层循环，避免每次都循环32次：我们可以用一个变量保存当前最大值。然而，由于32是常数，所以没有改变复杂度。另外，注意数组大小：max_bit数组大小32，a数组和dp数组大小为100000。具体代码实现：#include<iostream>#include<cstdio>#include<cstring>#include<algorithm>#include<cmath>#include<climits>usingnamespacestd;typedeflonglongll;constintmaxn=100000+10;inta[maxn];intdp[maxn];//dp[i]表示以a[i]结尾的最长子序列长度intmax_bit[32];//32位，0~31，记录每一位上当前的最大dp值（以该位为1的元素结尾的序列的最长长度）intmain(){intn;scanf("%d",&n);for(inti=0;i< n;i++){scanf("%d",&a[i]);}//初始化dp和max_bitmemset(max_bit,0,sizeof(max_bit));//全部初始为0//处理第一个元素dp[0]=1;for(intk=0;k<32;k++){if((a[0]>>k)&1){max_bit[k]=max(max_bit[k],dp[0]);//即1}}//从第二个元素开始for(inti=1;i< n;i++){dp[i]=1;//至少为1for(intk=0;k<32;k++){if((a[i]>>k)&1){dp[i]=max(dp[i],max_bit[k]+1);}}for(intk=0;k<32;k++){if((a[i]>>k)&1){max_bit[k]=max(max_bit[k],dp[i]);}}}intans=0;for(inti=0;i< n;i++){ans=max(ans,dp[i]);}printf("%d\n",ans);return0;}但是，我们考虑一下边界：当n=0时，但题目n>=1，所以不用处理。测试一下：输入：3123输出：2，正确。但是，我们考虑另一个例子：输入[1,3,5,2,4]1:二进制01->更新第0位：max_bit[0]=13:二进制11->第0位和第1位，从第0位转移：max_bit[0]+1=2；从第1位转移：max_bit[1]为0+1=1（但2更大）所以dp[1]=2。然后更新两位：max_bit[0]=max(1,2)=2，max_bit[1]=2。5:二进制101->第0位和第2位：第0位：max_bit[0]=2->2+1=3；第2位：max_bit[2]=0+1=1，所以dp[2]=3。然后更新max_bit[0]=max(2,3)=3，max_bit[2]=3。2:二进制10->第1位：从第1位转移：max_bit[1]=2+1=3？因为max_bit[1]=2（从3更新来的），所以dp[3]=max(1,2+1)=3。然后更新max_bit[1]=max(2,3)=3。4:二进制100->第2位：max_bit[2]=3（由5更新来的），所以dp[4]=3+1=4。然后更新max_bit[2]=4。所以答案是4？但实际序列：1,3,5,4：1&3->1&3!=0->3&5=1,5&4=4(非0)->所以序列1,3,5,4满足，长度为4。或者1,3,2,4：但2的二进制是10，3的二进制是11，3&2=2（非0），2&4=0（不行）->所以1,3,2,4不行。而1,3,5,4确实可以。因此，答案是4。我们的代码输出4，正确。但是，考虑另一个问题：子序列不要求连续，但我们的动态规划中，我们只保证了相邻两个的按位与非0。所以这个序列是满足的。因此，代码正确。然而，我们可以进一步优化：在更新dp[i]时，内层循环第一个循环是更新dp[i]为所有相关位中最大值+1。第二个循环是更新相关位的max_bit为dp[i]。但是，有没有可能不更新dp[i]？不会，因为至少dp[i]=1。所以，代码没有问题。但是，注意：题目要求相邻两个元素按位与非0，并没有要求整个序列的所有相邻元素满足，所以动态规划状态转移是合理的。最后，我们提交代码，可能会卡时间？因为3.2e6次运算，在C++中应该是很快的。但是，为了保险，我们可以用更快的读入（用scanf或者快读）。题目n=100000，scanf就够用了。因此，我们输出代码。注意：位运算的优先级：>>的优先级比&高，所以(a[i]>>k)&1是没问题的。最终代码：我们使用上述思路。但是，有一个小优化：在第一个循环中，我们可以在得到dp[i]后及时更新max_bit？不行，因为更新dp[i]需要所有相关位的max_bit，而如果我们在第一个循环中更新了某个位，那么后面的位可能就用到了这个更新，这是错误的。因此，必须等dp[i]确定之后，再去更新所有相关位的max_bit。所以，还是两个循环。提交代码。但是，还有一种可能：同一个数可能有多位，我们在更新dp[i]时用到了多位，然后我们只取这些位中最大的那个max_bit（实际上，每个位都加1然后取最大，相当于取所有相关位中max_bit的最大值，然后加1），这是合理的。如果某个数没有任何一位被设置（即0），那么它的二进制全0，那么两个循环都不会执行，dp[i]=1，然后也不会更新max_bit（因为没有位为1）。但是题目a[i]<=10^9，所以a[i]>=1，不会出现0。所以安全。因此，我们可以运行。代码：</think> 以下是解决给定问题的 C++ 代码实现，使用了动态规划结合位运算优化的方法，时间复杂度为 O(n * 32)，适用于最大数据规模 n=100,000。 ```cpp #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> using namespace std; const int MAXN = 100010; const int BITS = 32; // 32位，因为 a_i <= 10^9 (小于 2^30) int n; int a[MAXN]; int dp[MAXN]; // dp[i] 表示以第 i 个元素结尾的最长合法子序列长度 int max_bit[BITS]; // max_bit[k] 记录当前所有第 k 位为 1 的元素的最大 dp 值 int main() { scanf("%d", &n); for (int i = 0; i < n; i++) { scanf("%d", &a[i]); } // 初始化：第一个元素自己组成长度为 1 的子序列 memset(max_bit, 0, sizeof(max_bit)); // 所有位初始为 0 dp[0] = 1; for (int k = 0; k < BITS; k++) { if (a[0] & (1 << k)) { // 检查第 k 位是否为 1 max_bit[k] = dp[0]; // 更新对应位的最大值 } } // 处理后续元素 for (int i = 1; i < n; i++) { dp[i] = 1; // 至少可以单独作为一个子序列 // 检查所有位，利用第 k 位为 1 的位置进行状态转移 for (int k = 0; k < BITS; k++) { if (a[i] & (1 << k)) { // 如果当前元素的第 k 位为 1 dp[i] = max(dp[i], max_bit[k] + 1); } } // 更新当前元素对应所有位上的最大值 for (int k = 0; k < BITS; k++) { if (a[i] & (1 << k)) { max_bit[k] = max(max_bit[k], dp[i]); } } } // 寻找所有 dp 值中的最大值作为答案 int ans = 0; for (int i = 0; i < n; i++) { ans = max(ans, dp[i]); } printf("%d\n", ans); return 0; } ``` ### 代码解释： 1. **动态规划定义**： - `dp[i]` 表示以第 `i` 个元素结尾的最长子序列长度，满足该子序列中任意相邻两个元素按位与不为零。 2. **位运算优化**： - `max_bit[k]` 数组用于记录**遍历到当前位置时**，所有在第 `k` 位为 1 的元素中，最大的 `dp` 值。 - 对于一个元素 `a[i]`，如果它的第 `k` 位是 1，那么它可以接在**任何第 `k` 位为 1 的元素后面**形成合法子序列（因为按位与结果至少在该位为 1，保证不为零）。 3. **状态转移过程**： - **步骤 1**：对于当前元素 `a[i]`，检查它的每一位（0 到 31 位）。对于每个为 1 的位 `k`，使用 `max_bit[k] + 1` 来更新 `dp[i]`，表示将它接在对应位为 1 的元素后面。 - **步骤 2**：更新 `max_bit` 数组。对于 `a[i]` 的每一个为 1 的位 `k`，将 `max_bit[k]` 更新为当前的 `dp[i]`（如果当前值更大）。 4. **时间复杂度**： - 每个元素需要处理 32 位（常数），总体时间复杂度为 O(n × 32)，对于 n=100,000 完全可行（约 3.2e6 次操作）。 5. **边界处理**： - 第一个元素单独处理：`dp[0] = 1`，并初始化其对应位的 `max_bit` 值。 - 所有元素的最小长度至少为 1（只包含自身）。 6. **输入/输出**： - 使用 `scanf` 进行高效输入。 - 最终输出所有 `dp[i]` 中的最大值。 ### 示例输入输出验证： 输入： ``` 3 1 2 3 ``` 处理过程： 1. `a[0]=1` (二进制: `01`), `dp[0]=1`, 更新 `max_bit[0]=1` 2. `a[1]=2` (二进制: `10`) - 检查第1位为1：`max_bit[1]=0` → `dp[1]=max(1,0+1)=1` - 更新 `max_bit[1]=1` 3. `a[2]=3` (二进制: `11`) - 检查第0位：`max_bit[0]=1` → `2 = 1+1` - 检查第1位：`max_bit[1]=1` → `2 = max(1,1+1)` - `dp[2]=2` - 更新 `max_bit[0]=2`, `max_bit[1]=2` 4. 输出 `max(dp)=2`