前言

迭代加深算法是 dfs 的一种变形 ，能解决 dfs 时间复杂度高的坏处 ， 迭代加深又结合了 bfs 的优点，即可以算最小步数 ， 可以说是非常好的一种搜索算法

这个博客更新一些迭代加深算法的题目

题目

Guarding the Chessboard

大意：

给出一个 n * m 的棋盘， X 为所有的 标记点 ，问最少放多少个皇后可以覆盖所有的标记点；

思路

首先这是求最小步数的问题，其次时间限制为 10 s，非常宽裕 ， 直接使用迭代深搜算法；

注意当我们放下一个皇后后，我们要更新覆盖状态 ， 一个一个更新费时费力，我们可以用 行号 i 的状态代表当前行 的状态 ，用 列号 j 代表 当前列的状态 ，用 i+j 代表左斜列的状态 ，用 i - j + N 代表 右斜列的状态 (加N是为了保证这个数非负)；

所有的左斜列 的 i + j 不变
所有的右斜列 的 i - j 不变

代码

#include<bits/stdc++.h>

using namespace std;

int n,m,maxn;

int c[11][12];
char a;
bool vis[4][30];
bool flag;
const int N = 11;
int cnt;
//左斜 i+j 右斜 i-j+N

bool check()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			if(c[i][j]&&!vis[0][i]&&!vis[1][j]&&!vis[2][i+j]&&!vis[3][i-j+N]) return 0;
		}
	}
	return 1;
}
//检查所有的标记点是否被覆盖
//vis[0][i] 代表行覆盖状态
//vis[0][j] 代表列覆盖状态
//vis[0][i+j] 代表左斜覆盖状态
//vis[0][i-j+N] 代表右斜覆盖状态
//如果标记点 四个状态都是未标记，则标记无效

void dfs(int x,int y,int d)
{
	if(flag) return ;
	if(d==maxn+1)
	{
		if(check()) flag=1;//标记成功
		return ;
	}
	
	for(int i=x;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			int t1=vis[0][i],t2=vis[1][j],t3=vis[2][i+j],t4=vis[3][i-j+N];//记录标记前状态
			vis[0][i]=vis[1][j]=vis[2][i+j]=vis[3][i-j+N]=1;//改变标记状态
			if(j+1<=m) dfs(i,j+1,d+1);
			else if(i+1<=n) dfs(i+1,1,d+1);
			//搜索
			
			vis[0][i]=t1;vis[1][j]=t2;vis[2][i+j]=t3;vis[3][i-j+N]=t4;	
			//回溯
		}
	}
}

int main()
{
	while(cin>>n&&n)
	{
		cin>>m;
		getchar();
		getchar();
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m+2;j++)
			{
				a=getchar();
				if(a=='X') c[i][j]=1;
				else c[i][j]=0;
			}
		}
		
		for(maxn=1;;maxn++)
		{
			flag=0;
			memset(vis,0,sizeof(vis));
			dfs(1,1,1);
			
			if(flag)
			{
				cout<<"Case "<<++cnt<<": "<<maxn<<endl;
				break;
			}
		}
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

反思：

在 dfs 的循环 里面，循环体写的是

for(int i=x;i<=n;i++)
for(int j=1;j<=m;j++)
1
2

很容易引发我们的思考
1.为什么列是从 1 开始 而不是 从 y 开始的?
2.从 1 开始不就有冗余部分了吗？
3.列 从 y 开始 到底对不对；
4.既然和 y 无关，可不可以 dfs 只写两个参数
5.为什么一开始要写两个 getchar()，以及读入的时候为什么列是[ 1 - m+2 ];

问题一

我们从 x 开始 从 y 开始的目的只有一个 ，那就是 优化程序 ，不必要走之前已经搜索过的位置，但是，当我们列从 y 开始的时候 不只是本行点从 y 列开始，下面的所有行列都从 y 开始 ，下面行 y列 之前的点都被我们忽略掉了，这样少搜了点，程序必然是不对的

问题二

确实有冗余部分，但不多，基于时间范围比较大还是可以接受的

问题三

列可以从 y 开始 ，不过要改变一下写法，不能影响到本行以下的列
下面是从 y 开始的代码

	while(i<n)
    {
        while(j<m)
        {
            bool tmp1 = vis[0][i],tmp2 = vis[1][j],tmp3 = vis[2][i+j],tmp4 = vis[3][i-j+maxn];
            vis[0][i]=vis[1][j]=vis[2][i+j]=vis[3][i-j+maxn] = 1;
            if(dfs(i,j+1,d+1)) return 1;
            vis[0][i] = tmp1,vis[1][j] = tmp2,vis[2][i+j] = tmp3,vis[3][i-j+maxn] = tmp4;
            ++j;
        }
        j %= m,++i;
    }
1
2
3
4
5
6
7
8
9
10
11
12

问题四：

可以只写两个参数，因为确实与 y 无关

void dfs(int x,int d)
{
	if(flag) return ;
	if(d==maxn+1)
	{
		if(check()) flag=1;
		return ;
	}
	
	for(int i=x;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			int t1=vis[0][i],t2=vis[1][j],t3=vis[2][i+j],t4=vis[3][i-j+N];
			vis[0][i]=vis[1][j]=vis[2][i+j]=vis[3][i-j+N]=1;
			dfs(i,d+1);
			vis[0][i]=t1;vis[1][j]=t2;vis[2][i+j]=t3;vis[3][i-j+N]=t4;	
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

问题五：

因为 LDU 的 判题机系统的问题，当用 getchar() 读空格的时候要读 2 次，用其他方式 读字母不需要这样 ，但笔者习惯用 getchar()

最后，这个题收获了很多，首先是状态压缩，用一个数表示一部分数的状态，其次是加深了对迭代深搜问题的理解，加深了对 void 类型 dfs 写法 的熟练程度 ， 最后这个问题想了一下午，想通了真开心；