《算法竞赛进阶指南》破坏正方形

下图左侧显示了一个用 2424 根火柴棍构成的完整 3×33×3 网格。

所有火柴的长度都是 11。

您可以在网格中找到许多不同大小的正方形。

在左图所示的网格中，有 99 个边长为 11 的正方形，44 个边长为 22 的正方形和 11 个边长为 33 的正方形。

组成完整网格的每一根火柴都有唯一编号，该编号从上到下，从左到右，从 11 开始按顺序分配。

如果你将一些火柴棍从完整网格中取出，形成一个不完整的网格，则一部分正方形将被破坏。

右图为移除编号 12,1712,17 和 2323 的三个火柴棍后的不完整的 3×33×3 网格。

这次移除破坏了 55 个边长为 11 的正方形，33 个边长为 22 的正方形和 11 个边长为 33 的正方形。

此时，网格不具有边长为 33 的正方形，但仍然具有 44 个边长为 11 的正方形和 11 个边长为 22 的正方形。

现在给定一个（完整或不完整）的 n×nn×n（nn 不大于 55）网格，求至少再去掉多少根火柴棒，可以使得网格内不再含有任何尺寸的正方形。

输入格式

输入包含 TT 组测试用例。

测试用例的数量 TT 在输入文件的第一行中给出。

每个测试用例由两行组成：

第一行包含一个整数 nn，表示网格的规模大小。

第二行以非负整数 kk 开头，表示所给网格相较完整的 n×nn×n 网格所缺少的火柴杆数量，后跟 kk 个整数表示所有缺少的火柴杆的具体编号。

注意，如果 kk 等于零，则表示输入网格是完整的 n×nn×n 网格。

输出格式

每个测试用例输出一个结果，表示破坏所有正方形，所需的去掉火柴棒的最小数量。

每个结果占一行。

输入样例：

2
2
0
3
3 12 17 23

输出样例：

3
3

 

 

经典重复覆盖问题：
题目要求是不能有正方形存在：即转化为最少操作几次使得每个正方形的边都被破坏了
剪枝1：从小到大判断每个正方形是否被破坏，若未被破环则枚举依次破坏它的四条边（枚举的边少，分支少）
剪枝2：估价函数：枚举每个正方形，若碰到一个完整的正方形则将它的四条边
都破坏掉，切将破坏的边数记为1条边 

难点：如何记录正方形到数组中：
先定义：横边以它的左边为坐标原点，竖边以它的上边为坐标原点
则四个正方形的四个坐标如图：
r, c,为正方形所在的行列，len为正方形的边长，i为正方形边的编号
d为公差其值为d = 2 * n + 1，横着的边首相为1，竖着的边首项为n + 1;
则上边的正方形的编号为：(1 + r * d + c + i);
下边的正方形的编号为: (1 + (r + len) * d + c + i;
左边的正方形的编号为: (1 + n + (r + i) * d + c;
右边的正方形的编号为：(1 + n + (r + i) * d + c + len); 

 

s.push_back(1 + r * d + c + i);//上边第i个
s.push_back(1 + (r + len) * d + c + i);//下边第i个
s.push_back(1 + n + (r + i) * d + c);//左边第i个
s.push_back(1 + n + (r + i) * d + c + len);//右边第i个

#include 
#include 
#include 
#include 
 
const int N = 61;//正方形共有2 * n * (n + 1)条边
 
using namespace std;
 
int idx;//idx记录的是正方形的数目
int n, m;
vector<int> square[N];//记录正方形的每条边
bool used[N];//true编号为i的这个正方形的边已经被破坏，否则完整
 
void add(int r, int c, int len)
{
    int d = 2 * n + 1;//d为公差
    auto &s = square[idx];
    s.clear();//多组测试数据清空上次的测试数据
    
    for (int i = 0; i < len; i ++ )
    {
        s.push_back(1 + r * d + c + i);//上边第i个
        s.push_back(1 + (r + len) * d + c + i);//下边第i个
        s.push_back(1 + n + (r + i) * d + c);//左边第i个
        s.push_back(1 + n + (r + i) * d + c + len);//右边第i个
    }
    
    idx ++ ;//跳到下一个正方形
}
 
bool check(vector<int> &s)
{
    for (int i = 0; i < s.size(); i ++ )
        if (used[s[i]]) return false;//若有一条边被破坏则说明他不是完整的
        
    return true;//若所有边都为被破坏则他是完整的
}
 
int f()
{
    int res = 0;
    static bool temp[N];
    memcpy(temp, used, sizeof used);
    
    for (int i = 0; i < idx; i ++ )
        if (check(square[i]))//若正方形完整，则将正方形每条边都破坏，且记录只破坏了一条边
        {
            res ++ ;
            for (int j = 0; j < square[i].size(); j ++ )
            {
                used[square[i][j]] = true;
            }
        }
        
    memcpy(used, temp, sizeof temp);
    
    return res;
}
 
bool dfs(int depth, int max_depth)
{
    if (depth + f() > max_depth) return false;
    
    for (int i = 0; i < idx; i ++ )//枚举每个正方形
    {
        if (check(square[i]))//若编号为i的这个正方形是完整的； 
        {
            for (int j = 0; j < square[i].size(); j ++ )//依次删去它的每一条边
            {
                used[square[i][j]] = true;
                if (dfs(depth + 1, max_depth)) return true;
                used[square[i][j]] = false;
            }
            
            return false;//若每条边暴搜都不成功则说明max_depth步无法使得每个正方形边被爆破
        }
    }
    
    return true;//说明每个正方形都被破环
}
 
int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        idx = 0;
        memset(used, false, sizeof used);//多组测试数据情况数据
        
        scanf("%d", &n);
        for (int len = 1; len <= n; len ++ )
            for (int r = 0; r + len <= n; r ++ )
                for (int c = 0; c + len <= n; c ++ )
                    add(r, c, len);
        
        cin >> m;
        while (m -- )
        {
            int x;
            scanf("%d", &x);
            used[x] = true;
        }
        
        int depth = 0;//IDA*
        while (!dfs(0, depth)) depth ++ ;
        
        cout << depth << endl;
    }
    
    return 0;
}