ZOJ1031 Square Destroyer

 /*

此问题可以转化为一个图论的问题，把火柴看作另A类结点，正方形看作B类结点。

如果某根火柴在某个正方形的边上，那么我们就往这相应的两个结点添加一条边。

这样，问题转化为求该图中，最少用多少A类结点可以覆盖所有的B类结点。

当n=5时，A类结点数为：2n(n+1)=60；B类结点数为：n(n+1)(2n+1)/6=55。

可以见得，B类结点可以直接通过一个64位整型类储存。利用位运算，可以大大加快搜索速度。做法具体如下：

(1) 若有边(i, j)（分别属于A、B类结点，下同），则Aij = 0；否则Aij = 1；

(2) 对于每个确定的i，将Aij二进制编码至Bi中；

(3) 除去数据中没有的Bi，并编码初始状态st；

(4) 对于Bi按照可覆盖点数排序（优化1）；

(5) 若i<j，且Bi和Bj效果是一致的，则删掉Bj（优化2）；

(6) 计算opt[i] = Bi & B(i+1) & B(i+2) … & Bn（可行性剪枝）。

搜索过程，按照一般的方法做即可，添加最优性剪枝：若当前值大于阶段最剪枝，则跳出；

添加可行性剪枝，若取剩余所有的Bi也无法达到目标，则剪枝。

*/

#include<iostream>

using namespace std;

#include<vector>

long long rest,cover[60],remain[60];

int size,cnt,ans;

int up[6][6];

bool stick[60];

void initUP()

{

int i,j;

for(i=0;i<size;i++)

{

up[i][0] = i*(size*2+1);

for(j=1;j<size;j++)

{

up[i][j]=up[i][j-1]+1;

}

}

}

void initCover(int firststick,int sqsize,long long mask)

{

int i;

int gap=2*size+1;

int num=firststick;

for(i=0;i<sqsize;i++)

{

cover[num] |= mask;

cover[num+sqsize*gap] |= mask;

num++;

}

num = firststick+size;

for(i=0;i<sqsize;i++)

{

cover[num] |= mask;

cover[num+sqsize] |= mask;

num=num+gap;

}

}

void input()

{

int i,j,k,n;

cin>>size;

initUP();

cin>>cnt;

memset(stick,true,sizeof(stick));

for(i=0;i<cnt;i++)

{

cin>>n;

stick[n-1]=false;

}

long long mask=1;

memset(cover,0,sizeof(cover));

for(i=1;i<=size;i++)

{

for(j=0;j<=size-i;j++)

{

for(k=0;k<=size-i;k++)

{

initCover(up[j][k],i,mask);

mask<<=1;

}

}

}

}

void modify()

{

int i,j,rec;

rec=size*(size+1)*(2*size+1)/6;

rest=1;

for(i=1;i<rec;i++)

{

rest <<= 1;

rest += 1;

}

cnt=2*size*(size+1);

for(i=0;i<cnt;i++)

{

if(!stick[i]) rest &= ~cover[i];

}

for(i=0;i<cnt;i++)

{

cover[i] &= rest;

}

for(i=0;i<cnt;i++)

{

if(!stick[i]) continue;

else{

for(j=0;j<cnt;j++)

{

if(j != i && ((cover[i] & cover[j])==cover[j]))

stick[j]=false;

}

}

}

int c=0;

for(i=0;i<cnt;i++)

{

if(stick[i])

{

cover[c++] = cover[i];

}

}

cnt=c;

remain[cnt-1]=cover[cnt-1];

for(i=cnt-2;i>=0;i--)

{

remain[i]=remain[i+1] | cover[i];

}

}

void dfs(int c,int last,long long state)

{

if(state==rest){

ans=c;

// return;

}

else{

if(c<ans && (remain[last+1] | state)==rest){

for(int i=last+1;i<cnt;i++)

{

if((cover[i] | state) > state)

{

dfs(c+1,i,state | cover[i]);

}

}

}

}

}

int main()

{

int num;

cin>>num;

while(num--)

{

input();

modify();

ans=30;

dfs(0,-1,0);

cout<<ans<<endl;

}

return 0;

}