《FZU ACM 寒假第五讲：搜索算法》题解

最新推荐文章于 2025-05-17 15:18:37 发布

是小鱼儿嗷

最新推荐文章于 2025-05-17 15:18:37 发布

阅读量655

点赞数 15

分类专栏： FZU_ACM 文章标签：算法 c++ 深度优先广度优先图搜索算法数据结构

本文链接：https://blog.youkuaiyun.com/2301_76258100/article/details/145615195

版权

FZU_ACM 专栏收录该内容

7 篇文章

订阅专栏

题单链接：FZU ACM 寒假第五讲：搜索算法 - Virtual Judge

Easy：熟悉一下最基础的DFS和BFS题

1. 自然数的拆分问题

题目链接：

自然数的拆分问题 - 洛谷 P2404 - Virtual Judge

题意：

给定一个自然数 $n( 2\leq n \leq 8)$ ，要求将其拆分为若干个小于 $n$ 的自然数之和，并输出所有可能的拆分方案。每个拆分方案中的数字需要从小到大排列，且所有方案按照字典序升序输出。

解题思路：

这道题使用 深度优先搜索（DFS） 来枚举所有可能的拆分方案，并确保输出的方案按字典序排列。

首先，dfs(n, last) 递归地拆分数字 $n$ ，参数 last 控制本次拆分的最小数字，保证拆分后的序列单调递增。这样可以避免重复排列的出现，确保每种拆分方式唯一。

在 dfs 函数中，如果 $n=0$ ，说明当前序列是一个合法的拆分方案。此时输出该序列，并返回。但若当前序列只有一个元素，则不输出，因为题目要求至少要拆分成两个数。

递归过程中，枚举所有可能的拆分数 $i$ （从 last 开始到 $n$ ），将其加入 v，继续递归 dfs(n - i, i) 以拆分剩余的部分，回溯时再将其弹出 v，恢复现场。

最终，main() 负责输入整数 $n$ 并调用 dfs(n, 1)，开始搜索所有可能的拆分方案。

时间复杂度：

递归的深度最多为 $n$ ，因为最坏情况下拆分方案是 $n$ 个 1 相加，而每一层的分支数取决于当前剩余值 $n$ 以及可选的最小值 last。每次递归调用都会将问题规模缩小，因此形成了一棵搜索树。

整数拆分的总方案数是一个经典的组合数学问题，与分拆数函数 $p(n)$ 相关，其增长近似为指数级。因此整体复杂度可以近似估算为 $O(2^n)$ .

传送门：分拆数 - OI Wiki

AC代码：

#include <bits/stdc++.h>

using namespace std;

vector<int> v;

void dfs(int n, int last) {
	
	if (n == 0) {
		
		if (v.size() == 1)
			return;
		
		cout << v[0];
		for (int i = 1; i < v.size(); ++ i) {
			cout << "+" << v[i];
		}
		cout << endl;
		
		return;
	}
	
	for (int i = last; i <= n; ++ i) {
		v.push_back(i);
		dfs(n - i, i);
		v.pop_back();
	}
}

int main() {
	
	int n;
	cin >> n;
	
	dfs(n, 1);
	
	return 0;
}

2. 填涂颜色

题目链接：

填涂颜色 - 洛谷 P1162 - Virtual Judge

题意：

给定一个 $n \times n$ 的矩阵，由数字 0 和 1 组成。其中 1 形成一个闭合圈，且圈内至少包含一个 0。

要求将闭合圈内部的所有 0 替换为 2，并输出修改后的矩阵。

解题思路：

本题通过 深度优先搜索（DFS） 进行矩阵遍历，找出矩阵中被 1 形成的闭合圈包围的 0，并将其填充为 2。

首先，定义 mark_bound(x, y) 递归标记所有可以直接或间接连通到矩阵边界的 0。这些 0 不能填充 2，因此用 not_2[][] 记录它们。遍历矩阵四条边上的 0，调用 mark_bound 标记所有连通的 0。

接着，遍历整个矩阵，寻找所有既是 0，又未被 not_2[][] 标记的位置，即被 1 形成的闭合圈包围的 0，调用 mark_2(x, y) 递归地将其填充为 2。

最后，遍历输出填充后的矩阵。

时间复杂度：

每个 0 最多被访问两次（一次在 mark_bound，一次在 mark_2），矩阵的总大小为 $n^2$ ，所以时间复杂度为 $O(n^2)$ 。

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};

const int N = 30 + 1;

int n;
int a[N][N];

bool not_2[N][N];

bool available(int x, int y) {
	return x >= 1 && x <= n && y >= 1 && y <= n;
}

void mark_bound(int x, int y) {
	
	not_2[x][y] = true;
	
	for (int i = 0; i < 4; ++ i) {
		int nx = x + dx[i];
		int ny = y + dy[i];
		if (available(nx, ny) && a[nx][ny] == 0 && ! not_2[nx][ny]) {
			mark_bound(nx, ny);
		}
	}
}

void mark_2(int x, int y) {
	
	a[x][y] = 2;
	
	for (int i = 0; i < 4; ++ i) {
		int nx = x + dx[i];
		int ny = y + dy[i];
		if (available(nx, ny) && a[nx][ny] == 0) {
			mark_2(nx, ny);
		}
	}
}

int main() {
	
	cin >> n;
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= n; ++ j) {
			cin >> a[i][j];
		}
	}
	
	for (int i = 1; i <= n; ++ i) {
		if (a[1][i] == 0) mark_bound(1, i);
		if (a[n][i] == 0) mark_bound(n, i);
		if (a[i][1] == 0) mark_bound(i, 1);
		if (a[i][n] == 0) mark_bound(i, n);
	}
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= n; ++ j) {
			if (! not_2[i][j] && a[i][j] == 0) {
				mark_2(i, j);
			}
		}
	}
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= n; ++ j) {
			cout << a[i][j] << ' ';
		}
		cout << endl;
	}
	cout << endl;
	
	return 0;
}

Medium：需要你想一想后再写的题目

1. 显示图像

题目链接：

显示图像 - 洛谷 P1256 - Virtual Judge

题意：

给定一个 $N \times M$ 的二进制矩阵，其中 1 代表白色像素点，0 代表黑色像素点。要求计算每个黑色像素点到最近的白色像素点的最短曼哈顿距离。

解题思路：

通过 广度优先搜索（BFS） 算法计算每个黑色像素 (0) 到最近的白色像素 (1) 的最短曼哈顿距离。首先，读取输入并存储矩阵。然后将所有白色像素 (1) 作为起始点，加入队列，并标记为已访问。接着使用 BFS 扩展搜索，从队列中依次取出像素点，遍历其四个邻近方向（上下左右），若是未访问的 0，则更新其最短距离并加入队列。直到遍历完所有像素点，最终每个像素点到最近的白色像素的最短曼哈顿距离都会被计算出来。

时间复杂度：

每个像素点至多被访问一次，因此 BFS 的时间复杂度是 $O(NM)$ ，其中 $N$ 和 $M$ 是矩阵的行数和列数。

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 182 + 5;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};

int n, m;
int a[N][N], d[N][N];
bool vis[N][N];

bool available(int x, int y) {
	return x >= 1 && x <= n && y >= 1 && y <= m;
}

int main() {
	
	cin >> n >> m;
	
	queue<pair<int, int>> Q;
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= m; ++ j) {
			char ch;
			cin >> ch;
			a[i][j] = ch - '0';
			if (a[i][j] == 1) {
				vis[i][j] = true;
				Q.push({i, j});
			}
		}
	}
	
	while (! Q.empty()) {
		
		int x = Q.front().first;
		int y = Q.front().second;
		Q.pop();
		
		for (int i = 0; i < 4; ++ i) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if (available(nx, ny) && ! vis[nx][ny]) {
				vis[nx][ny] = true;
				d[nx][ny] = d[x][y] + 1;
				Q.push({nx, ny});
			}
		}
	}
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= m; ++ j) {
			cout << d[i][j] << ' ';
		}
		cout << endl;
	}
	cout << endl;
	
	return 0;
}

2. 健康的荷斯坦奶牛 Healthy Holsteins

题目链接：

健康的荷斯坦奶牛 Healthy Holsteins - 洛谷 P1460 - Virtual Judge

题意：

题目要求选择最少数量的饲料，使得牛每天对各类维他命的需求得到满足。每种饲料最多只能使用一次，若有多个解，选择字典序最小的方案。

解题思路：

本题是一个典型的“背包问题”变种，要求最小化所选择的饲料数量，同时满足每种维他命的需求。通过暴力穷举所有饲料组合，并使用 深度优先搜索（DFS） 来找到满足需求的最优解。DFS每次尝试选择一个饲料或不选择，并更新每种维他命的数量，直到找到最优解。最优解包括两个方面：首先是选择饲料的数量最少，其次是字典序最小。

时间复杂度：

最坏情况下需要遍历所有的饲料组合，并且每个组合都需要检查维他命需求，因此时间复杂度为 $O(2^g \times v)$ .

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int V = 25 + 1;
const int G = 15 + 1;

int v, g;

int need[V];
int feed[G][V];

int cnt[V];

vector<int> vec;
vector<int> ans;

bool ok() {
	
	for (int i = 1; i <= v; ++ i) {
		if (cnt[i] < need[i]) {
			return false;
		}
	}
	return true;
}

void dfs(int k) {
	
	if (ok()) {
		if (ans.empty())
			ans = vec;
		else if (ans.size() > vec.size())
			ans = vec;
		else if (ans.size() == vec.size() && vec < ans)
			ans = vec;
		return;
	}
	
	if (k > g) {
		return;
	}
	
	// 选
	vec.push_back(k);
	for (int i = 1; i <= v; ++ i)
		cnt[i] += feed[k][i];
	dfs(k + 1);
	vec.pop_back();
	for (int i = 1; i <= v; ++ i)
		cnt[i] -= feed[k][i];
	
	// 不选
	dfs(k + 1);
}

int main() {
	
	cin >> v;
	
	for (int i = 1; i <= v; ++ i) {
		cin >> need[i];
	}
	
	cin >> g;
	
	for (int i = 1; i <= g; ++ i) {
		for (int j = 1; j <= v; ++ j) {
			cin >> feed[i][j];
		}
	}
	
	dfs(1);
	
	cout << ans.size() << ' ';
	
	for (const auto& el : ans) {
		cout << el << ' ';
	}
	cout << endl;
	
	return 0;
}

Hard：需要一些较为复杂的剪枝操作

1. GRZ-Ridges and Valleys

题目链接：

GRZ-Ridges and Valleys - 洛谷 P3456 - Virtual Judge

题意：

给定一个 $n \times n$ 的地势图，每个格子有一个高度值，要求找出山峰和山谷的数量。其中，山峰是指所有相邻的高度小于当前点的集合，山谷则是所有相邻的高度大于当前点的集合。

解题思路：

首先，需要定义每个格子的邻域。每个格子最多有8个邻居（包括上下左右以及四个对角线方向）。然后，使用 广度优先搜索（BFS） 遍历整个地图，从每个未访问的格子开始，判断其是否属于一个新的区域。在遍历过程中，需要判断该区域是否满足山峰或山谷的条件。具体来说，如果一个格子比它所有的邻居都高，则是山峰；如果比所有邻居都低，则是山谷。如果有邻居高度相同，则该区域既不是山峰也不是山谷。为了避免重复计算，使用vis数组来标记每个格子是否已经被访问过。最后，遍历所有格子并统计山峰和山谷的数量，最后输出结果。

时间复杂度：

每个格子只会被访问一次，时间复杂度为 $O(n^2)$ .

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 1000 + 5;

const int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};

int n, a[N][N];
bool vis[N][N];

int r_count, v_count;

bool available(int x, int y) {
	return x >= 1 && x <= n && y >= 1 && y <= n;
}

void bfs(int sx, int sy) {
	
	bool is_r = true;
	bool is_v = true;
	
	queue<pair<int, int>> Q;
	vis[sx][sy] = true;
	Q.push({sx, sy});
	
	while (! Q.empty()) {
		
		int x = Q.front().first;
		int y = Q.front().second;
		Q.pop();
		
		for (int i = 0; i < 8; ++ i) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if (available(nx, ny)) {
				if (a[nx][ny] == a[x][y] && ! vis[nx][ny]) {
					vis[nx][ny] = true;
					Q.push({nx, ny});
				}
				if (a[nx][ny] < a[x][y]) {
					is_v = false;
				}
				if (a[nx][ny] > a[x][y]) {
					is_r = false;
				}
			}
		}
	}
	
	if (is_r) r_count ++;
	if (is_v) v_count ++;
}

int main() {
	
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	
	cin >> n;
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= n; ++ j) {
			cin >> a[i][j];
		}
	}
	
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= n; ++ j) {
			if (! vis[i][j]) {
				bfs(i, j);
			}
		}
	}
	
	cout << r_count << ' ' << v_count << endl;
	
	return 0;
}

2. 八皇后 Checker Challenge

题目链接：

八皇后 Checker Challenge - 洛谷 P1219 - Virtual Judge

题意：

在一个 $n \times n$ 的棋盘上放置 $n$ 个棋子，使得每行、每列各有且仅有一个棋子，同时任意对角线（包括主对角线及其平行线）至多有一个棋子。找出所有满足条件的放置方案，并按字典序输出前 3 组解，最后一行输出解的总数。

解题思路：

使用 回溯（DFS） 逐行放置棋子，确保每列和两条对角线至多有一个棋子。定义 y[j] 标记列是否已被占用，d1[i - j + n] 和 d2[i + j] 标记两条对角线是否已被占用。每次递归放置棋子时，依次尝试每列，若满足约束条件，则递归进入下一行；回溯时撤销本次选择。最终对所有解进行字典序排序，输出前 3 个解和解的总数。

时间复杂度：

回溯的复杂度约为 $O(n!)$ ，但由于 $n \leq 13$ ，使用剪枝优化后仍然可行。

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 13 + 1;

int n, y[N], d1[2 * N], d2[2 * N];

vector<int> v;
vector<vector<int>> ans;

void dfs(int i) {
	
	if (i > n) {
		ans.push_back(v);
		return;
	}
	
	for (int j = 1; j <= n; ++ j) {
		if (y[j] == 0 && d1[i - j + n] == 0 && d2[i + j] == 0) {
			y[j] ++;
			d1[i - j + n] ++;
			d2[i + j] ++;
			v.push_back(j);
			dfs(i + 1);
			v.pop_back();
			y[j] --;
			d1[i - j + n] --;
			d2[i + j] --;
		}
	}
}

int main() {
	
	cin >> n;
	
	dfs(1);
	
	sort(ans.begin(), ans.end());
	
	for (int i = 0; i < 3; ++ i) {
		for (const auto& el : ans[i]) {
			cout << el << ' ';
		}
		cout << endl;
	}
	
	cout << ans.size() << endl;
	
	return 0;
}

学习总结：

在《FZU ACM 寒假第五讲：搜索算法》的学习过程中，我通过六道典型的题目深入理解了搜索算法在不同场景下的应用。

首先，在 "最少饲料问题" 中，我使用 深度优先搜索（DFS）+ 剪枝 来求解最优解。该问题的关键在于合理选择饲料，使得所选饲料数量最少且能够满足所有营养需求。我在搜索过程中利用 回溯+最优性剪枝 来减少无效搜索，提高了算法效率。

接着，在 "山峰和山谷" 这道题中，我应用了 广度优先搜索（BFS） 进行连通块的遍历。通过判断每个连通块的周围高度关系，我成功区分了 ridges（山脊）和 valleys（山谷）。该题让我对 多方向搜索和连通性判断 有了更深刻的理解。

在 "八皇后 Checker Challenge" 这道题中，我采用了 回溯搜索（Backtracking）+ 剪枝 来生成所有合法的棋子摆放方案，并按字典序输出前三个解。这里的核心是 使用数组记录列与对角线的占用情况，避免冲突，从而减少搜索空间，提高求解效率。

通过这几道题目，我加深了对 DFS、BFS、回溯法及剪枝优化 的理解，并在实践中掌握了 如何高效处理状态空间搜索问题。此外，这些题目涉及的 最优性问题、连通性问题、排列问题 也让我对搜索算法的广泛应用有了更直观的认识。在后续的学习中，我将继续深入研究更高级的搜索优化技术，如 启发式搜索、A 算法、迭代加深搜索* 等，不断提升自己的算法能力。