FZU ACM 2025寒假集训，专题5搜索算法

最新推荐文章于 2025-06-02 20:51:47 发布

Funny Valentine-js

最新推荐文章于 2025-06-02 20:51:47 发布

阅读量859

点赞数 14

文章标签：深度优先算法

本文链接：https://blog.youkuaiyun.com/2301_80437645/article/details/145568776

版权

一个朴实无华的目录

一:做题思路
二：知识点总结

一:做题思路

在这里插入图片描述

1.自然数的拆分问题

#include<bits/stdc++.h>
using namespace std; 
int n; 
int ans;//当前的加和值
int a[10] = {1};//存储当前的拆分方案
void dfs(int s) {//递归的深度第s层
    for (int i = a[s - 1]; i < n; i++) {
    	if (ans + i <= n) {
      	ans += i;
      	a[s] = i;
      	if (ans == n) {
        	for (int j = 1; j < s; j++)
          		cout << a[j] << "+";
        		cout << a[s] << endl;
     	}
        else 
        	dfs(s + 1);
      	ans -= i;
    	} 
    }
}

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

2.自然数的拆分问题

#include <iostream>
#include <vector>
using namespace std;

#define MAXN 35

int grid[MAXN][MAXN]; // 存储矩阵
int n; // 矩阵大小
int directions[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; // 四个方向的偏移量

// 深度优先搜索函数，用于标记可淹没的区域
void dfs(int x, int y) {
    // 将当前点标记为已淹没
    grid[x][y] = 0;

    // 遍历四个方向
    for (int i = 0; i < 4; i++) {
        int nx = x + directions[i][0];
        int ny = y + directions[i][1];

        // 检查是否在矩阵范围内，并且该位置是可淹没区域
        if (nx >= 0 && nx <= n + 1 && ny >= 0 && ny <= n + 1 && grid[nx][ny] == 2) {
            dfs(nx, ny); // 递归处理相邻的可淹没区域
        }
    }
}

int main() {
    // 初始化矩阵，所有位置都设为可淹没区域
    for (int i = 0; i < MAXN; i++) {
        for (int j  =0; j < MAXN; j++) {
            grid[i][j] = 2;
        }
    }

    // 输入矩阵的实际大小
    cin >> n;

    // 输入矩阵内容
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            int value;
            cin >> value; // 输入矩阵中的每个位置的值
 if            (value == 1) {
                grid[i][j] = 1; // 如果输入为1，标记为障碍物
            }
        }
    }

    // 从矩阵的左上角(0, 0)开始进行DFS
    dfs(0, 0);

    // 输出处理后的矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j ++){
            cout << grid[i][j] << " ";
        }
        cout << endl; // 每行结束后换行
    }

    return 0;
}

3.显示图像

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;

#define MAXN 1005

int n, m;
char a[MAXN][MAXN] = {0}; // 存储输入的矩阵
bool memo[MAXN][MAXN]; // 存储搜索状态
int ans[MAXN][MAXN] = {0}; // 存储每个位置到最近白色区域的距离

// 判断(x, y)是否越界
bool edge(int x, int y) {
    return x > 0 && x <= n && y > 0 && y <= m;
}

// BFS函数
void bfs() {
    queue<pair<int, int>> q; // 使用队列存储待处理的坐标
    int dx[4] = {1, -1, 0, 0}; // 方向数组
    int dy[4] = {0, 0, 1, -1};

    // 将所有白色区域加入队列
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (a[i][j] == '1') {
                q.push({i, j});
                memo[i][j] = true;
                ans[i][j] = 0; // 白色区域到自己的距离为0
            }
        }
    }

    // BFS遍历
    while (!q.empty()) {
        auto [x, y] = q.front();
        q.pop();

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];

            if (edge(nx, ny) && !memo[nx][ny]) {
                memo[nx][ny] = true;
                ans[nx][ny] = ans[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }
}

int main() {
    memset(memo, false, sizeof(memo)); // 初始化memo为false
    cin >> n >> m; // 输入矩阵大小

    // 读入矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> a[i][j];
        }
    }

    // 调用BFS函数
    bfs();

    // 输出结果
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cout << ans[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

4.健康的荷斯坦奶牛

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits> // 用于 INT_MAX
using namespace std;

int V, G;
vector<int> need; // 牛每天需要的每种维生素的最小量
vector<vector<int>> feed; // 每种饲料包含的维生素量
vector<int> selected; // 当前选择的饲料编号
vector<int> best; // 最优解的饲料编号
vector<int>::size_type min_feed = UINT_MAX; // 最少的饲料种类数，使用无符号类型

// 检查当前选择的饲料是否满足所有维生素的需求
bool check() {
    vector<int> vitamins(V, 0);
    for (int i : selected) {
        for (int j = 0; j < V; j++) {
            vitamins[j] += feed[i][j];
        }
    }
    for (int i = 0; i < V; i++) {
        if (vitamins[i] < need[i]) return false;
    }
    return true;
}

// 深度优先搜索
void dfs(int idx, vector<int>::size_type count) {
    if (count >= min_feed) return; // 剪枝：当前选择的饲料种类数已经超过已知的最小种类数
    if (check()) { // 如果当前组合满足所有维生素需求
        if (count < min_feed) { // 更新最小饲料种类数
            min_feed = count;
            best = selected;
        } else if (count == min_feed) { // 如果饲料种类数相同，选择字典序最小的组合
            if (selected < best) {
                best = selected;
            }
        }
        return;
    }
    for (int i = idx; i < G; i++) { // 尝试选择编号为i的饲料
        selected.push_back(i);
        dfs(i + 1, count + 1); // 递归搜索
        selected.pop_back(); // 回溯
    }
}

int main() {
    cin >> V;
    need.resize(V);
    for (int i = 0; i < V; i++) {
        cin >> need[i];
    }

    cin >> G;
    feed.resize(G, vector<int>(V));
    for (int i = 0; i < G; i++) {
        for (int j = 0; j < V; j++) {
            cin >> feed[i][j];
        }
    }

    dfs(0, 0);

    cout << min_feed << " ";
    for (vector<int>::size_type i = 0; i < best.size(); i++) {
        cout << best[i] + 1 << (i == best.size() - 1 ? "\n" : " ");
    }

    return 0;
}

5.Ridges and Valleys

#include<bits/stdc++.h>

#define MAXn 1010

using namespace std;

int n;
int a[MAXn][MAXn];//图中各点高度 
int vis[MAXn][MAXn];//标记数组 
int high, low;//高的连通块个数，低的连通块个数 
int d[3] = {-1, 0, 1};//坐标增量 

int dfs(int x, int y, int num)
{
	if(a[x][y] != num)//如果是非连通块点 
		return num > a[x][y];//返回连通块是否更高 
		
	vis[x][y] = num;//做标记 
	int res = 2;//返回结果统计值
	 
	for(int i = 0; i < 3; i++)
		for(int j = 0; j < 3; j++)
		{
			if(x + d[i] < 1 || x + d[i] > n || y + d[j] < 1 || y + d[j] > n)//判断是否越界 
				continue;
			if(vis[x + d[i]][y + d[j]] == num)//判断是否被同种连通块搜过 
				continue;
				
			int tmp = dfs(x + d[i], y + d[j], num);//这个点 搜索结果 
			if(res == 2)//还没有统计过任何值，直接赋值 
				res = tmp;
			else if(tmp == 2)//搜索结果为2表示这个点周围点都被搜过了 
			    continue;
			else if(tmp == -1)//直接置为-1 
			    res = -1;
			else if(res != tmp)//不相等置为-1 
				res = -1;
		}
	return res;
}

int main()
{
	scanf("%d", &n);
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= n; j++)
			scanf("%d", &a[i][j]);
	
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= n; j++)
		{
			if(vis[i][j])//是否被搜过 
				continue;
			int flag = dfs(i, j, a[i][j]);//该联通块搜索结果 
			if(flag == 1)
				high++;
			else if(flag == 0) 
				low++;
			else if(flag == 2)//有个特例需要判断一下，既图中所有点都是同高度的，那么两者同时加1 
			    low++, high++;
		}
	}
	
	printf("%d %d", high, low);//输出结果 
	
	return 0;
}

6.八皇后 Checker Challenge

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int n;
vector<int> cols; // 记录每一列是否被占用
vector<int> diag1; // 记录主对角线是否被占用
vector<int> diag2; // 记录副对角线是否被占用
vector<int> solution; // 当前解
vector<vector<int>> solutions; // 所有解

// 检查是否可以放置棋子
bool canPlace(int row, int col) {
    return !cols[col] && !diag1[row + col] && !diag2[row - col + n - 1];
}

// 回溯法
void dfs(int row) {
    if (row == n) { // 找到一个解
        solutions.push_back(solution);
        return;
    }
    for (int col = 0; col < n; col++) {
        if (canPlace(row, col)) {
            cols[col] = true;
            diag1[row + col] = true;
            diag2[row - col + n - 1] = true;
            solution[row] = col + 1; // 记录当前行的列号
            dfs(row + 1);
            cols[col] = false;
            diag1[row + col] = false;
            diag2[row - col + n - 1] = false;
        }
    }
}

int main() {
    cin >> n;
    cols.resize(n, false);
    diag1.resize(2 * n - 1, false);
    diag2.resize(2 * n - 1, false);
    solution.resize(n);

    dfs(0);

    // 输出前3个解
    for (int i = 0; i < min(3, int(solutions.size())); i++) {
        for (int j = 0; j < n; j++) {
            cout << solutions[i][j] << (j == n - 1 ? "\n" : " ");
        }
    }

    // 输出解的总数
    cout << solutions.size() << endl;

    return 0;
}

二：知识点总结

深度优先

全排列问题

求自然数 1 到 n 所有的排列，即 n 的全排列。
在这里插入图片描述
我们注意到每次处理盒子的过程是相似的。
不妨考虑使用递归。

假如边界条件终止循环。

走迷宫问题

给定一个 N * M 方格的迷宫，迷宫里有 T 处障碍，障碍处不可通过。
在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。
给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方
案。

开一个二维的 bool 数组 vis，vis[i][j]=true代表（i，j）这个格子已经被访问过了。每
次决策只去走 vis[x][y]=false 的格子，把 vis[x][y] 先修改为 true，回溯的时候改回
false，就可以避免走回头路的问题。
在这里插入图片描述

广度优先

走迷宫（改）问题

输入一个 n*m 的迷宫和它起点与终点的坐标，输出走出这个迷宫的最短路径长度。
使用队列存格子坐标xy，步数step,搜索过程中，从队首取出状态进行拓展，
产生新的状态，检测新状态的合法性后加入队尾。
最后，从队首取出的第一个坐标是终点的
状态用的步数就是最短路径长度。