1084:正方形破坏者

描述

左图展示了一个由 24 根火柴棍组成的 3 * 3 的网格，所有火柴棍的长度都是 1。在这张网格图中有很多的正方形：边长为 1 的有 9 个，边长为 2 的有 4 个，边长为 3 的有 1 个。

每一根火柴棍都被编上了一个号码，编码的方式是从上到下：横着的第一行，竖着的第一行，横着的第二行一直到横着的最后一行。在同一行内部，编码的方式是从左到右。 其中对 3 * 3 的火柴网格编码的结果已经标在左图上了。

右图展示了一个不完整的 3 * 3 的网格，它被删去了编号为 12,17,23 的火柴棍。删去这些火柴棍后被摧毁了 5 个大小为 1 的正方形，3 个大小为 2 的正方形和 1 个大小为 3 的正方形。（一个正方形被摧毁当且仅当它的边界上有至少一个火柴棍被移走了）

可以把上述概念推广到 n * n 的火柴棍网格。在完整的 n * n 的网格中，使用了 2n(n+1) 根火柴棍，其中边长为 i(i ∈ [1,n]) 的正方形有 (n-i+1)2个。

现在给出一个 n * n 的火柴棍网格，最开始它被移走了 k 根火柴棍。问最少再移走多少根火柴棍，可以让所有的正方形都被摧毁。

输入
输入包含多组数据，第一行一个整数 T 表示数据组数。

对于每组数据，第一行输入一个整数 n 表示网格的大小( n <= 5)。第二行输入若干个空格隔开的整数，第一个整数 k 表示被移走的火柴棍个数，接下来 k 个整数表示被移走的火柴棍编号。
输出
对于每组数据，输出一行一个整数表示最少删除多少根火柴棍才能摧毁所有的正方形。
样例输入
2
2
0
3
3 12 17 23
样例输出
3
3

---

分析

我们先只考虑没有拿走火柴棒的网格图

设base[i][j] 表示第i行第j列的正方形 需要火柴的状态

设squ[i]表示编号为i的正方形 需要火柴的状态

预处理出 边长为1的正方形

然后枚举他要往右下延伸的长度

然后枚举延伸之后的正方形的每个网格

squ[i]^=base[][]

1^1=0，如果一个火柴棒是两个小正方形的交接处，组成大的正方形之后，这个火柴棒不再参与构成正方形的边，正好异域掉

然后迭代加深搜索

估价函数：

设一开始拿走一些火柴棒之后的网格图 有状态为S 的火柴棒

枚举所有的正方形i

如果squ[i]&s == squ[i] 说明在S状态下，正方形i还没有被破坏

让s^=squ[i]，need++

即暂时破坏这个正方形,拿走这个正方形的所有火柴棒，算作一根火柴棒，继续枚举

如果枚举完后，当前拿走的火柴棒+need>限制，剪枝

因为所有的正方形都要被破坏，所以与枚举顺序无关

---

代码

​
#include<cstdio>

using namespace std;

typedef long long LL;
int n,cnt,maxd,tot;
LL bit[61];
LL base[6][6],squ[56];
int get_ud(int i,int j)
{
    return (2*n+1)*(i-1)+j-1;
}

int get_lr(int i,int j)
{
    return (2*n+1)*(i-1)+j+n-1;
}

void build()
{
    cnt=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            base[i][j]=0;
            base[i][j]|=bit[get_ud(i,j)]|bit[get_ud(i+1,j)];
            base[i][j]|=bit[get_lr(i,j)]|bit[get_lr(i,j+1)];
            squ[++cnt]=base[i][j];
        }
    for(int siz=2;siz<=n;siz++)
        for(int i=1;i+siz-1<=n;i++)
            for(int j=1;j+siz-1<=n;j++)
            {
                squ[++cnt]=0;
                for(int w=0;w<siz;w++)
                    for(int h=0;h<siz;h++)
                        squ[cnt]^=base[i+w][j+h];
            }
}

bool dfs(int d,LL state)
{
    if(d==maxd) 
    {
        for(int i=1;i<=cnt;i++)
            if((squ[i]&state)==squ[i]) return false;
        return true;
    }
    LL s=state;
    int need=0,del=0;
    for(int i=1;i<=cnt;i++)
        if((squ[i]&s)==squ[i])
        {
            need++;
            s^=squ[i];
            if(!del) del=squ[i];
        }
    if(d+need>maxd) return false;
    for(int i=1;i<=tot;i++)
        if((del&bit[i-1])==bit[i-1])
            if(dfs(d+1,state^bit[i-1])) return true;
    return false;
}

int main()
{
    int T;
    scanf("%d",&T);
    bit[0]=1;
    for(int i=1;i<=60;i++) bit[i]=bit[i-1]<<1;
    int m,x; LL state;
    while(T--)
    {
        scanf("%d",&n);
        tot=2*n*(n+1); state=bit[tot]-1;
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d",&x);
            state^=bit[x-1];
        }
        build();
        for(maxd=0;;maxd++) 
         if(dfs(0,state)) break;
        printf("%d\n",maxd);
    }
}

​

给个赞和关注吧