c++算法基础——搜索入门

一、DFS（深度搜索)

用于全排列，遍历等问题。

int u=0;
int n=3;
int path[1000];
bool st[1000];
void dfs(int u){
	if(u==n){
	for(int i=0;i<n;i++){
	printf("%d ",path[i]);
	}
	puts("");
	}
	for(int i=1;i<=n;i++){
		if(!st[i]){
			path[u]=i;
			st[i]=true;
			dfs(u+1);
			st[i]=false;
			
		}
}
}

结果： 1
	1 2 3 
	1 3 2
	2 1 3
	2 3 1
	3 1 2
	3 2 1

数 羊群问题

#include<bits/stdc++.h>
using namespace std;
int n, m;
char field[101][101];
int dx[4][4] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
void dfs(int x, int y);
int main(){
        int t;
        cin >> t;
        while(t--){
                int res = 0;
                scanf("%d%d", &n, &m);
                cin.get();
                for (int i = 0; i < n;i++){
                        for (int j = 0; j < m;j++){
                                scanf("%c", &field[i][j]);
                        }
                        cin.get();
                }

                for (int i = 0; i < n;i++){
                        for (int j = 0; j < m;j++){

                                if (field[i][j] == '#'){
                                        dfs(i, j);
                                        res++;
                                }
        }
                }
                printf("%d\n", res);
                }
}
void dfs(int x, int y){
        field[x][y] = '.';
        for (int i = 0; i < 4;i++){
                int nx = x + dx[i][0], ny = y + dx[i][1];
                if (nx >= 0 && nx < n && ny >= 0 && ny < m&&field[nx][ny]=='#'){
                        dfs(nx, ny);
                }
        }
        return;
}

二、BFS（广度搜索）

用于迷宫等的最小路径等问题。

 #include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000; //标志为未走过的路径
typedef pair<int, int> P;
const int maxm = 100;
const int maxn = 100;

int main()
{
    char maze[maxm][maxn + 1]; //迷宫
    int N, M,i,j,K;
    int sx, sy;
    int gx,gy;
    int d[maxm][maxn];//各点到起始点的距离，若为INF则无法到达

    cin >> N >> M;

    for (i = 0; i<N; i++){
    for (j = 0; j<M; j++){
        cin >> maze[i][j];
        if(maze[i][j]=='S')
        {
            sx = i, sy = j;
        }
        if (maze[i][j] == 'P')
        {
            gx = i, gy = j;
        }
 
}
}
int dx[4] = {1, 0, -1, 0},dy[4] = {0, 1, 0, -1};
queue<P> que;
for (i = 0; i < N; i++)
{
    for (j = 0; j < M; j++)
    {
        d[i][j] = INF;
    }
}
que.push(P(sx, sy));
d[sx][sy] = 0;
while(que.size()){
    P p = que.front();
    que.pop();
    if(p.first==gx&&p.second==gy)
        break;
    for (i = 0; i < 4;i++){
        int nx = p.first + dx[i], ny = p.second + dy[i];
        if(nx>=0&&nx<N&&ny>=0&&ny<M&&maze[nx][ny]!='*'&&d[nx][ny]==INF){
            que.push(P(nx, ny));
            d[nx][ny] = d[p.first][p.second] + 1;
        }
    }
}

cout <<d[gx][gy]<<endl;
return 0;
    }