第五节——探索深度优先搜索、广度优先搜索及相关技巧（记忆化和剪枝）

nansen210716

已于 2025-02-13 17:37:05 修改

阅读量882

点赞数 24

文章标签：深度优先宽度优先剪枝

于 2025-02-13 17:36:39 首次发布

本文链接：https://blog.csdn.net/lj222225536/article/details/145602885

版权

引言

在算法的世界里，深度优先搜索（DFS）和广度优先搜索（BFS）是解决图和树结构问题的两大支柱。今天，我们将深入探讨这两种搜索技术，了解它们如何帮助我们探索未知的领域，并找到解决问题的方法。

深度优先搜索（DFS）

DFS是一种利用栈（显式或递归）来实现的搜索算法，它尽可能深地搜索图的分支。DFS的特点是它总是先探索尽可能深的分支，然后再回溯。这种策略使得DFS成为实现回溯算法的理想选择，后者通过试错来寻找问题的解决方案。

广度优先搜索（BFS）

与DFS不同，BFS使用队列来实现逐层逐层的节点访问。BFS的特点是它总是先访问离根节点最近的节点，这使得BFS在解决最短路径问题或层次结构的遍历中表现出色。

搜索算法的优化

尽管DFS和BFS在许多情况下都非常有用，但在面对大规模数据时，它们可能会遇到效率问题。这时，优化技巧如剪枝和记忆化就显得尤为重要。

剪枝：通过提前终止无效的搜索分支来减少计算量。
记忆化：存储已经计算过的状态以避免重复计算，从而提高效率。

题目分析

1.自然数的拆分问题

该题是一道简单的dfs，截止条件为所有子数相加大于等于原数，输出条件为所有子数相加等于原数并且字典序排序，right判断字典序，dfs组合排列。

#include<iostream>
using namespace std;
bool b[10] = { false };
int arr[10] = { 0 };
int n, len = 0;
bool right() {
   for (int i = 1; i < len; i++) {
       if (arr[i] < arr[i - 1])return false;
   }
   return true;
}
void dfs(int a) {
   if (a > n) {
       return;
   }
   if (a == n) {
       if (right()) {
           for (int i = 0; i < len - 1; i++) {
               cout << arr[i] << '+';
           }
           cout << arr[len - 1] << endl;
       }
       return;
   }
   for (int i = 1; i < n; i++) {
       if (b[len] == true)continue;
       b[len] = true;
       arr[len++] = i;
       dfs(a + i);
       b[--len] = false;
   }
}
int main() {
   cin >> n;
   dfs(0);
   return 0;
}

2.填涂颜色

该题可用bfs搜索，对未被搜索过的区域内的一个0进行bfs，当有一个bfs满足未到达过边境，停止继续新的bfs，以该bfs的标记值判断是否输出2，其余数为0或1。

#include<iostream>
#include<queue>
using namespace std;
int mp[32][32] = { 0 };
int n, b = 2;
struct xy {
   int x, y;
};
struct xy mo[4] = { {0,1},{0,-1},{1,0},{-1,0} };
bool bfs(int x, int y) {
   bool pan = true;
   queue<struct xy>Q;
   Q.push({ x,y });
   mp[x][y] = b;
   struct xy f;
   while (!Q.empty()) {
       f = Q.front();
       Q.pop();
       for (int i = 0; i < 4; i++) {
           int mx = f.x + mo[i].x, my = f.y + mo[i].y;
           if (mx > n || mx<1 || my>n || my < 1) {
               pan = false;
               continue;
           }
           else if (mp[mx][my] == 0 && (mx == n || mx == 1 || my == n || my == 1))pan = false;
           if (mp[mx][my] == 0)Q.push({ mx,my }), mp[mx][my] = b;
       }
   }
   return pan;
}
int main() {
   cin >> n;
   for (int i = 1; i <= n; i++) {
       for (int j = 1; j <= n; j++) {
           cin >> mp[i][j];
       }
   }
   bool f = false;
   for (int i = 2; i < n; i++) {
       for (int j = 2; j < n; j++) {
           if (mp[i][j] == 0) {
               b++;
               if (f = bfs(i, j))break;
           }
       }
       if (f)break;
   }
   for (int i = 1; i <= n; i++) {
       for (int j = 1; j <= n; j++) {
           if (mp[i][j] == b)cout << 2;
           else if (mp[i][j] == 1)cout << 1;
           else cout << 0;
           cout << ' ';
       }
       cout << endl;
   }
   return 0;
}

3.显示图像

该题输入由于没有空格，所以用getcahr()；

题目所求每一个0到1的距离；

显然，由每一个0开始搜索一遍会超时，可以转换为从每一个1开始搜索，记录连通的0与它的距离，当有更短距离时更新，当所有1都搜索一遍过后得到最优解。

#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
using namespace std;
typedef struct xy {
   int x, y;
}xy;
xy mo[4] = { {0,1},{0,-1},{1,0},{-1,0} };
vector<xy>lig;
int n, m;
int mp[185][185] = { 0 };
int d[185][185] = { 0 };
void bfs(int x, int y) {
   bool b[185][185] = { false };
   queue<struct xy>Q;
   Q.push({ x,y });
   xy f;
   int dist;
   while (!Q.empty()) {
       f = Q.front();
       Q.pop();
       dist = d[f.x][f.y];
       for (int i = 0; i < 4; i++) {
           int mx = f.x + mo[i].x, my = f.y + mo[i].y;
           if (b[mx][my] || mx > n || mx<1 || my>m || my < 1 || d[mx][my] == 1)continue;
           if (d[mx][my] > dist + 1)d[mx][my] = dist + 1;
           else continue;
           b[mx][my] = true;
           Q.push({ mx,my });
       }
   }
}
int main() {
   memset(d, 127, sizeof(d));
   cin >> n >> m;
   char c;
   getchar();
   for (int i = 1; i <= n; i++) {
       for (int j = 1; j <= m; j++) {
           c=getchar();
           if(c=='0')mp[i][j] = 0;
           else {
               mp[i][j] = 1;
               d[i][j] = 1;
               lig.push_back({ i,j });
           }
       }
       getchar();
   }
   for (int i = 0; i < lig.size(); i++) {
       bfs(lig[i].x, lig[i].y);
   }
   for (int i = 1; i <= n; i++) {
       for (int j = 1; j <= m; j++) {
           cout << d[i][j] - 1 << ' ';
       }
       cout << endl;
   }
   return 0;
}

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

dfs构造组合并且判断是否满足最低维生素数量，更新最低需要的饲料袋子，a、b数组分别记录当前最优的答案和正在累计的答案，最后输出。

#include<iostream>
using namespace std;
int v, g, sum[30] = { 0 }, vi[30], mi = 30, ans = 0, gi[30][30], a[30], b[30];
void dfs(int x)
{
   bool f = false;
   for (int i = 1; i <= v; i++) {
       if (sum[i] < vi[i]) { f = true; break; }
   }
   if (!f) {
       if (ans < mi) {
           mi = ans;
           for (int i = 1; i <= ans; i++)a[i] = b[i];
       }
       return;
   }
   else {
       ans++;
       b[ans] = x;
       for (int i = 1; i <= v; i++)sum[i] = sum[i] + gi[x][i];
       for (int i = 1; i <= g - x + 1; i++)dfs(x + i);
       for (int i = 1; i <= v; i++)sum[i] = sum[i] - gi[x][i];
       ans--;
   }
}
int main()
{
   cin >> v;
   for (int i = 1; i <= v; i++) {
       cin >> vi[i];
   }
   cin >> g;
   for (int j = 1; j <= g; j++) {
       for (int i = 1; i <= v; i++)cin >> gi[j][i];
   }
   dfs(0);
   cout << mi - 1 << " ";
   for (int i = 2; i <= mi; i++) {
       cout << a[i] << " ";
   }
}

5.GRZ-Ridges and Valleys

该题为bfs宽搜，用不同的标记记录不同高低的连通块，随后根据题意判断是峰还是谷。

由于数据较大，取消流同步加快读取。

#include<iostream>
#include<cstdio>
#include<cctype>
using namespace std;
const int N = 1010;
int v[N][N], a[N][N], n, l, r, s1, s2;
int mx[8] = { -1,-1,-1,0,0,1,1,1 };
int my[8] = { -1,0,1,-1,1,-1,0,1 };
struct no { int x, y; }Q[N * N];
void bfs(int i, int j) {
   Q[1] = { i,j };
   int c1 = 1, c2 = 1;
   for (l = r = 1; l <= r; ++l)
       for (int k = 0; k < 8; ++k) {
           int nxi = Q[l].x + mx[k], nxj = Q[l].y + my[k];
           if (nxi<1 || nxi>n || nxj<1 || nxj>n) continue;
           if (a[nxi][nxj] == a[i][j])
               if (!v[nxi][nxj]) {
                   Q[++r] = { nxi,nxj };
                   v[nxi][nxj] = 1;
               }
           if (a[nxi][nxj] < a[i][j]) c2 = 0;
           if (a[nxi][nxj] > a[i][j]) c1 = 0;
       }
   s1 += c1; s2 += c2;
}

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 (!v[i][j]) bfs(i, j);
   }
   cout << s1 << ' ' << s2 << '\n';
   return 0;
}

6.八皇后 Checker Challenge

该题的难点在于如何判断棋子是否在对角线上。

观察可知，对于正对角线，行号减列号的值相等，对于反对角线，行号和列号的和相等，由此可以判断是否可以构成正解。

AC代码如下：

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int n, a[100] = { 0 }, b[100] = { 0 }, arr[100];
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 (arr[j] == 0 && a[i + j] == 0 && b[i - j + 50] == 0) {
           arr[j]=1;
           a[i + j]=1;
           b[i - j + 50] = 1;
           v.push_back(j);
           dfs(i + 1);
           v.pop_back();
           arr[j] = 0;
           a[i + j] = 0;
           b[i - j + 50] = 0;
       }
   }
}
int main() {
   cin >> n;
   dfs(1);
   for (int i = 0; i < 3; i++) {
       for (int j = 0; j < ans[i].size(); j++) {
           cout << ans[i][j] << ' ';
       }
       cout << endl;
   }
   cout << ans.size();
   return 0;
}