kuangbin 简单搜索 - POJ 1321 （dfs模板题）

链接：Click here ~~~

1.棋盘问题题意及题解

给定一个棋盘，旗子（都相同）不能放在同一行或者同一列，明显,dfs入门模板题（类似于八皇后问题）。采用dfs算法，可以一行一行搜，也可以一列一列搜索。（以下给出一行一行搜索的方法）用一个二维数组char map[][]数组记录棋盘，用bool cln[] 布尔数组记录这一列是否有棋子，深搜结束条件：搜索到最后一行。判断条件：如果这一列没有棋子且这一行有棋子，就可以放一个棋子，然后继续搜索。（代码有注释，详情可看代码）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>

#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define ll long long
//#define int ll
#define INF 0x3f3f3f3f
using namespace std;
int read()
{
	int w = 1, s = 0;
	char ch = getchar();
	while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { s = s * 10 + ch - '0';    ch = getchar(); }
	return s * w;
//最大公约数
}int gcd(int x,int y) {
    if(x<y) swap(x,y);//很多人会遗忘，大数在前小数在后
    //递归终止条件千万不要漏了，辗转相除法
    return x % y ? gcd(y, x % y) : y;
}
int lcm(int x,int y)//计算x和y的最小公倍数
{
    return x * y / gcd(x, y);//使用公式
}
//------------------------ 以上是我常用模板与刷题几乎无关 ------------------------//
char map[10][10];//记录地图
bool cln[10];//查看这一列有没有棋子
int n, k;
int res;
void dfs(int r, int num)//深搜
{
	//结束条件
	if (num == k) {
		res++;
		return;
	}
	if (r > n)
		return;
	for (int i = 1; i <= n; ++i) {
		//判断条件，如果这一列没有棋子且这一行有棋子，就可以执行
		if (cln[i] == false && map[r][i] == '#') {
			cln[i] = true;
			dfs(r + 1, num + 1);//搜索下一行
			cln[i] = false;
		}
	}
	dfs(r + 1, num);
}
int main()
{
	IOS;
	while (cin >> n >> k) {
		if (n == -1 && k == -1)
			break;
		memset(cln, false, sizeof(cln));//初始化cln为false即没有棋子
		for (int i = 1; i <= n; ++i)
			for (int j = 1; j <= n; ++j)
				cin >> map[i][j];//输入棋子
		dfs(1, 0);//开始搜索
		printf("%d\n", res);
		res = 0;//初始化结果，以免妨碍下一轮
	}
	return 0;
}

类似题目：

2.dfs处理全排列的问题

给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

输入格式
共一行，包含一个整数n。

输出格式
按字典序输出所有排列方案，每个方案占一行。

数据范围
$1\le n\le 7$
输入样例：

3

输出样例：

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

DFS的路线图：

我们不需要存这个树，每次深搜走到底就是一条路线。

回溯的过程中需要注意：恢复原样。flag[i] = false;

代码（爆搜）：

1.C++代码实现

#include<iostream>
using namespace std;

const int N = 10;
int n;
int path[N];//保存路径
bool flag[N];
void dfs(int u)//u代表层数，u==n的时候就是叶节点。
{
	if (u == n) {
		for (int i = 0; i < n; i++)
			printf("%d ", path[i]);
		puts("");//输出空行
		return;
	}

	for (int i = 1; i <= n; i++) {
		//如果当前这个数没有被用过
		if (!flag[i]) {
			path[u] = i;//填写i
			flag[i] = true;
			dfs(u + 1);//进入下一层递归，递归函数之后记得要恢复原状
			flag[i] = false;//回溯之后需要恢复原样
		}
	}
}
int main()
{
	cin >> n;
	dfs(0);
	return 0;
}

2.Java代码实现

import java.util.Scanner;
public class Main {
    static int n;
    static int[] path;//保存路径
    static boolean[] flag;//打标记
    //u代表层数，u == n的时候就是叶节点
    public static void dfs(int u) {
        if (u == n) {
            for (int i = 0; i < n; i++) {
                System.out.print(path[i] + " ");
            }
            System.out.println();
            return;
        }
        for (int i = 1; i <= n; i++) {
            //如果这个数没有被用过
            if (!flag[i]) {
                path[u] = i;//填写i
                flag[i] = true;
                dfs(u + 1);//进入到下一层递归，递归函数之后记得要恢复原状
                flag[i] = false;//回溯之后需要恢复原样
            }
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        path = new int[n];
        flag = new boolean[n + 1];
//        long startTime = System.currentTimeMillis();
        dfs(0);
//        long endTime = System.currentTimeMillis();
//        System.out.println("运行时间:" + (endTime - startTime) + "ms");
    }
}

3.八皇后问题（DFS经典问题）

剪枝：提前终止搜索，直接回溯，不用继续往下搜索了。

1.第一种搜索方式 ：按行搜索（全排列思想）：

#include<iostream>
using namespace std;

const int N = 20;

int n;
char path[N][N];//path代表路径
bool col[N], dg[N], udg[N];//col代表列，dg代表正对角线，udg代表反对角线

void dfs(int row)
{
	//当u==n时，表示已经搜了n行，所以输出这条路径
	if (row == n) {
		for (int i = 0; i < n; i++)
			cout << path[i] << endl;
		cout << endl;
		return;
	}

	//当前枚举第u行，看皇后放在哪一列
	for (int i = 0; i < n; i++)
		// 剪枝 ，如果皇后在一列且正反对角线都没有。
		if (!col[i] && !dg[row + i] && !udg[n - row + i]) {
			path[row][i] = 'Q';//填写皇后
			col[i] = dg[row + i] = udg[n - row + i] = true;
			dfs(row + 1);
			//回溯之后需要恢复原样
			col[i] = dg[row + i] = udg[n - row + i] = false;
			path[row][i] = '.';

		}
}
int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n; j++)
			path[i][j] = '.';//地图上先打满点
	dfs(0);
	return 0;
}

解释一下第24行代码，dg和udg数组下标问题。 👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆👆

2.第二种搜索方式 ：（搜索每个点）

#include<iostream>
using namespace std;

const int N = 20;

int n;
char path[N][N];//path代表路径
bool row[N], col[N], dg[N], udg[N];//row代表行，col代表列，dg代表正对角线，udg代表反对角线

void dfs(int x, int y, int s)
{
	
	if (s > n)
		return;
	//搜索到出界，换行
	if (y == n) {
		y = 0;
		x++;
	}
	if (x==n) {
		if (s == n) {
			for (int i = 0; i < n; i++)
				cout << path[i] << endl;
			cout << endl;
			return;
		}
	}

	path[x][y] = '.';
	dfs(x, y + 1, s);
	//如果这一行没有，这一列没有，正对角线没有，反对角线也没有。则放一个皇后。
	if (!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n]) {
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
		path[x][y] = 'Q';
		dfs(x, y + 1, s + 1);
		path[x][y] = '.';
		row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
	}
}
int main()
{
	cin >> n;

	dfs(0, 0, 0);

	return 0;
}