【算法总结】“穷竭”搜索

一、深度优先搜索

POJ No.2386 Lake Counting

Description

Due to recent rains, water has pooled in various places in Farmer John's field, which is represented by a rectangle of N x M (1 <= N <= 100; 1 <= M <= 100) squares. Each square contains either water ('W') or dry land ('.'). Farmer John would like to figure out how many ponds have formed in his field. A pond is a connected set of squares with water in them, where a square is considered adjacent to all eight of its neighbors. 

Given a diagram of Farmer John's field, determine how many ponds he has.
Input

* Line 1: Two space-separated integers: N and M 

* Lines 2..N+1: M characters per line representing one row of Farmer John's field. Each character is either 'W' or '.'. The characters do not have spaces between them.
Output

* Line 1: The number of ponds in Farmer John's field.
Sample Input

10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.
Sample Output

3
Hint

OUTPUT DETAILS: 

There are three ponds: one in the upper left, one in the lower left,and one along the right side.

　　从任意'W'开始，不断将其八连通区域内的'W'换成'.'。则一次DFS后与起始点'W'相连接的所有'W'都被替换为'.'，说明此次DFS找到了一个水洼。当图中不再有‘W'时，说明所有水洼都被找到。DFS的次数就等于水洼的个数。

　　需要注意的是，scanf("%c", &ch)会将空格、换行符等空字符也作为合法输入，所以需要用 getchar()跳过空字符。

#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <math.h>
using namespace std;

const int MAX = 100 + 5;
int N, M;
char field[MAX][MAX];

void dfs(int x, int y) {
    field[x][y] = '.';
    // 遍历八连通区域
    for (int dx = -1; dx <= 1; ++dx) { 
        for (int dy = -1; dy <= 1; ++dy) {
            int nx = dx + x, ny = dy + y;
            if (0 <= nx && nx < N && 0 <= ny && ny < M && field[nx][ny] == 'W')
                dfs(nx, ny);
        }
    }
}

int main() {
    while (scanf("%d%d", &N, &M) != EOF) {
        for (int i = 0; i < N; ++i) {
            getchar(); // 为了跳过换行符
            for (int j = 0; j < M; ++j) {
                // scanf("%c", &ch) 会将空格和换行符等空字符作为合法输入
                scanf("%c", &field[i][j]);
            }
        }
        int num = 0;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < M; ++j) {
                if (field[i][j] == 'W') {
                    dfs(i, j);
                    ++num;
                }
            }
        }

        printf("%d
", num);
    }
    system("pause");
    return 0;
}

二、宽度优先搜索

　　宽度优先搜索总是先搜索距离初始状态近的状态，开始状态->只需一次转移就可以到达的所有状态->只需2次转移就可以到达的所有状态->。。。对于同一个状态，BFS只经过一次。复杂度为O(状态数$ imes$转移的方式）。

迷宫的最短路径

　　给定一个大小为N*M的迷宫，迷宫由通道和墙壁组成，每一步移动可以向邻接的上下左右四格的通道移动。。试求出起点到终点所需的最小步数。（本题假定从起点一定可以移动到终点。'#', ’.’，'S', 'G' 分别表示墙壁、通道、起点和终点）

　　宽度优先搜索按照据开始状态由近及远的顺序进行搜索，因此可以很容易地来求最短路径、最少操作之类问题的答案。此题中状态仅仅是目前位置的坐标，因此可以构造为pair或者编码为int来表达状态。当状态更加复杂时，需要封装成一个类来表示状态。转移的方向为4个，状态数与迷宫的大小相等。那么复杂度为$O(4 imes N imes M)=O(N imes M)$。

　　宽度优先搜索与深度优先搜索一样，都会生成所有能够遍历到的状态，因此需要对所有状态进行处理时使用宽度优先搜索也是可以的。

　　宽度优先搜索中，只要将已经访问过的状态用标记管理起来，就可以很好地做到由近及远的搜索。这个问题中由于要求最短距离，不妨用d[N][M]数组把最短距离保存起来。初始时用充分大的常数INF来初始化它，这样尚未到达的位置就是INF，也就同时起到了标记的作用。虽然到达终点时就会停止搜索，可如果继续下去直到队列为空的话，就可以计算出到各个位置的最短距离。此外，如果搜索到最后，d依然为INF的话，便可得知这个位置就是无法从起点到达的位置。

#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <math.h>
#include <queue>  
using namespace std;

const int MAX_N = 100 + 5;
const int MAX_M = 100 + 5;
const int INF = 0x3f3f3f3f; // 常用用法，防止溢出
typedef pair<int, int> P;

char maze[MAX_N][MAX_M]; // 迷宫数组
int N, M;
int sx, sy; //起点的位置  
int gx, gy; //终点的位置  

int d[MAX_N][MAX_M];//到各个位置的最短距离的数组  
int dx[4] = { 1, 0, -1, 0 }, dy[4] = { 0, 1, 0, -1 }; // 4个方向

void bfs() { // 状态转移次数即距离
    queue<P> que;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            d[i][j] = INF;  //初始化起始点到所有点的距离为INF  
    // 将起始点假如队列，并将这一地点的距离设置为0
    que.push(P(sx, sy));
    d[sx][sy] = 0;

    //不断循环直到队列的长度为0
    while (que.size()) {
        P p = que.front(); que.pop();
        // 已经到达终点则结束搜索
        if (p.first == gx && p.second == gy)
            break;

        for (int i = 0; i < 4; i++) {
            // 移动后的位置坐标
            int nx = p.first + dx[i];
            int ny = p.second + dy[i];
            //判断是否可移动到该位置以及该位置是否已经被访问过  
            if (0 <= nx && nx < N && 0 <= ny && ny < M  // 坐标合法，未溢出
                && maze[nx][ny] != '#' // 该位置不是障碍
                && d[nx][ny] == INF) {//已经被访问过的话不用考虑，因为距离在队列中是递增的 

                que.push(P(nx, ny));    //可以移动则加入队列，并且该位置的距离为到p的距离+1  
                d[nx][ny] = d[p.first][p.second] + 1;
            }
        }
    }
}

int main()
{
    scanf("%d%d", &N, &M);
    for (int i = 0; i < N; ++i) {
        getchar();
        for (int j = 0; j < M; ++j) {
            scanf("%c", &maze[i][j]);
            if (maze[i][j] == 'S')
            {
                sx = i; sy = j;
            }
            if (maze[i][j] == 'G')
            {
                gx = i; gy = j;
            }
        }
    }
    bfs();
    printf("%d
", d[gx][gy]);

    return 0;
}

三、特殊状态枚举 　　

　　虽然生成可行解空间多数采用深度优先搜索，但在状态空间比较特殊时其实可以很简短地实现。比如，C++的标准库中提供了next_permutation这一函数，可以把n个元素共n!种不同的排列生成出来。又或者，通过使用位运算，可以枚举从n个元素中取出k个的共$ extrm{C}_{n}^{k}$种状态或是某个集合中的全部子集等。

四、剪枝

　　深度优先搜索时，有时早已很明确地知道从当前状态无论如何转移都不会存在解。这种情况下，不再继续搜索而是直接跳过，这一方法被称作剪枝。