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

F - Magic Bitwise And Operation HDU 4016
暴力剪枝
1：a&b<=min(a,b)故最大值可以边dfs边更新
2：预处理：将数组排序，提前处理出后缀与数组，然后用当前值与当前后缀与，如果得到的结果仍小于记录的最小值，该情况舍去

代码如下：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N =100;
const ll mxx=0x7fffffffffffffff;
ll num[N],sum[N],mx;
int n,k;
void dfs(int t,int d,ll now)
{
    if(mx>now)mx=now;                   //随时更新mx
    if(t==k||d==n)return;
    if((now&sum[d])>=mx)return;         //剪枝
    dfs(t+1,d+1,now&num[d]);                //暴力枚举
    dfs(t,d+1,now);
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int j=1;j<=T;j++)
    {
        ll ans;
        scanf("%d%d",&n,&k);
        for(int i=0;i<n;i++)scanf("%lld",&num[i]);
        sort(num,num+n);
        mx=mxx;
        sum[n-1]=num[n-1];
        for(int i=n-2;i>-1;i--)
        {
            sum[i]=num[i]&sum[i+1];
        }
        dfs(0,0,mxx);
        printf("Case #%d: %lld\n",j,mx);
    }
    return 0;
}

B - Paint on a Wall HDU 4012
状压bfs
总的来说就是暴力枚举，每次遍历（图上）每一个点并考虑可以从该点开扩展的最大面积（即不遇到已经符合要求的点）
利用0，1表示符合/不符合要求（即颜色是否与要求符合）来做状态压缩；这里不考虑多种颜色的影响，因为只要颜色不符合要求，最终都是会被涂掉的，不需要单独考虑。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
struct node
{
    int val,step;
    node(int v,int s):val(v),step(s){};
};
queue <node> q;
char s[20];
int n;
bool flag[1<<20];
int bfs()
{
    memset(flag,false,sizeof(flag));
    node x = node(0,0);
    while(!q.empty())q.pop();
    flag[0]=true;
    q.push(x);
    while(!q.empty())
    {
        node u = q.front();
        q.pop();
        if(u.val==((1<<(2*n))-1))return u.step;
        for(int i=0;i<2*n;i++)
        {
            if((1<<i)&u.val)continue;
            int temp = 0;
            //单行
            for(int j=i;j<(1+i/n)*n;j++) //右扩展
            {
                if((1<<j)&u.val)break;
                if(s[j]==s[i])temp |= (1<<j);
            }
            for(int j=i-1;j>=(i/n)*n;j--)  //左扩展
            {
                if((1<<j)&u.val)break;
                if(s[j]==s[i])temp |= (1<<j);
            }
            for(int j=temp;j;j=temp&(j-1))  //加入子集，j-1意味着每次删掉一个涂色，这就代表一个子状态。
            {
                if(flag[u.val|j])continue;             //已经出现过的状态不予考虑，原因是他的所有子状态均已经被考虑过了。
                flag[u.val|j]=true;
                q.push(node((u.val|j),u.step+1));
            }
            //多行
            if(i>=n)continue;         //只考虑单行
            if(u.val&(1<<(i+n)))continue;
            temp=0;
            for(int j=i;j<n;j++)
            {
                if(((1<<j)&u.val)||(1<<(j+n)&u.val))break;
                if(s[j]==s[i])temp |= (1<<j);
                if(s[j+n]==s[i])temp |= (1<<(j+n));
            }
            for(int j=i-1;j>=0;j--)
            {
                if(((1<<j)&u.val)||((1<<(j+n))&u.val))break;
                if(s[j]==s[i])temp |= (1<<j);
                if(s[j+n]==s[i])temp |= (1<<(j+n));
            }
            for(int j=temp;j;j=temp&(j-1))
            {
                if(flag[u.val|j])continue;                            //这里和之前的continue改成break也能过，还会快100多ms，
                														但个人觉得应当考虑所有的子状态。
                flag[u.val|j]=true;
                q.push(node((u.val|j),u.step+1));
            }
        }
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int i=1;i<=T;i++)
    {
        scanf("%d",&n);
        scanf("%s%s",s,s+n);
        printf("Case #%d: %d\n",i,bfs());
    }
    return 0;
}