欢迎使用优快云-markdown编辑器

最新推荐文章于 2021-01-07 23:01:28 发布

neuike

最新推荐文章于 2021-01-07 23:01:28 发布

阅读量187

点赞数

CC 4.0 BY-SA版权

文章标签：搜多

本文链接：https://blog.youkuaiyun.com/neuike/article/details/51841773

本文介绍了一种通过位运算寻找给定整数集合中选择特定数量元素进行按位与操作后得到最小值的问题。该文详细阐述了如何利用递归搜索结合剪枝策略来高效求解，并提供了一个具体的实现示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

标题 ##Magic Bitwise And Operation

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65768/65768 K (Java/Others)
Total Submission(s): 1551 Accepted Submission(s): 610

Problem Description
Given n integers, your task is to pick k out of them so that the picked number are minimum when do bitwise “AND” among all of them.
For example, there are three integers 5, 6 and 7. You are asked to pick two of them. Your possible strategy is (5, 6), (5, 7) or (6, 7). The values when do bitwise and all the picked numbers together are as follows:
5 and 6 = 4
5 and 7 = 5
6 and 7 = 6
The smallest one is 4.

Input
There are multiple test cases for this problem. The first line of the input contains an integer denoting the number of test cases.
For each test case, there are two integers in the first line: n and k, denoting the number of given integers and the number of integers you are asked to pick out. n <= 40
The second line contains the n integers. You may assume that all integers are small than 2^60.

Notes: There are about one thousand randomly generated test cases. Fortunately 90% of them are relatively small.

Output
For each test case, output only one integer is the smallest possible value.

Sample Input
3
3 2
5 6 7
8 2
238 153 223 247 111 252 253 247
40 10
1143632830316675007 558164877202423550 1152356080752164603 1143911006781551605 1132655005501751263
1152919305583327167 1141662230660382702 862439259920596463 1151777428397603327 1008771132016295871
855666336963428351 1151795583225167807 1152634943314572791 1071856693060561407 1132650872803426303
1124211056982081471 1152917106425982911 1152815392070041535 1080863910568853481 288230371856350975
1080720560532488126 864686455262281727 576460673919991167 574191342855241589 1152233760050118651
1152921504605798263 1152912708241186815 1079738008506187487 1075796261476483027 1080854478820730879
1152885219917823999 1151725162940854259 1147529498501577715 571956602920235519 1134545630643616248
1152921218991521790 1152921496000052703 1142788250826440703 1151654831778151421 1152780747522637695

Sample Output
Case #1: 4
Case #2: 9
Case #3: 36028797086245424

Source
The 36th ACM/ICPC Asia Regional Shanghai Site —— Warmup

Recommend
lcy

题意
给出n个数字要求从中间挑选出m个数字，使得这m个数字与运算的结果最小。
思路
直接搜索即可。注意要剪枝，因为1数位是越与越少的，所以可以将当前所得到的数字和剩下的所有数字进行与运算，如果比ans要小，那么才继续进行搜索，否则直接终止当前的搜索。

#include<cstdio>
#include<iostream>
#include<algorithm>

using namespace std;
typedef long long ll;
int n,m;
ll a[100];
ll pre[100];

ll ans=0;


void dfs(int pos,int num,ll x)
{

    if(pos==n)
    {
        if(num==m)
        {
            ans=min(ans,x);
        }
        return ;
    }
    if(num==m)
    {
        ans=min(ans,x);
        return ;
    }
    if(num>m)
        return ;
    //printf("%lld   %lld\n",pre[pos+1],pre[pos]);
    if(pos+1<n&&(x&pre[pos])>=ans)
        return ;

    dfs(pos+1,num+1,x&a[pos]);
    dfs(pos+1,num,x);
}
int main()
{

    int T;
    scanf("%d",&T);
    int cas=1;
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
        {
            scanf("%lld",&a[i]);
           // printf("%lld\n",a[i]);
        }
        sort(a,a+n);
        ans=((ll)1<<63)-1;

        for(int i=0;i<m;i++)
        {
            ans=ans&a[i];
          //  printf("%lld\n",ans);
        }
        pre[n-1]=a[n-1];
        for(int i=n-2;i>=0;i--)
            pre[i]=pre[i+1]&a[i];
       // printf("ans:%lld\n",ans);
        dfs(0,0,((ll)1<<63)-1);

        printf("Case #%d: %lld\n",cas++,ans);

    }

    return 1;
}