穷竭搜索

                                             穷竭搜索

概念：将所有的可能性罗列出来，在其中寻找答案的方法

1. 递归函数

如计算阶乘

    int fact(int n){
        if(n == 0)    return 1;
        return n*fact(n-1);        

2. 栈

c++调用栈库函数

#include<stack>
#include<cstdio>
using namespace std;

int main(){
    stack<int> s;

    s.push(1);
    s.push(2);
    s.push(3);
    printf("%d\n", s.top());
    s.pop();
    printf("%d\n", s.top());
    s.pop();
    printf("%d\n", s.top());
    s.pop();

    return 0;
}

3. 队列

c++队列库函数

#include<queue>
#include<cstdio>
using namespace std;

int mian(){
    queue<int> que;
    que.push(1);
    que.push(2);
    printf("%d\n", que.front());
    queue.pop();
    printf("%d\n", que.front());
    queue.pop();

    return 0;
}

4. 深度优先搜索

    它从某个状态开始，不断的转移状态直到无法转移，然后回退到前一步的状态，继续转移到其他状态，如此不断重复，直到找到最终的解。例如求数独。

例： 给定整数a1，a2，........a3，判断是否可以从中选出若干数，使他们的和恰好为K。

从a1开始顺序决定每个数加还是不加，在全部n个数都决定后再判断他们的和是不是K即可。

int a[N];
int n, k;

bool dfs(int i, int sum){
    if(i == N)
        return sum == k;
    if(dfs(i+1, sum))
        return true;
    if(dfs(i+1, sum+a[i]))
        return true;
    return false;

}



void solver(){
    if(dfs(0,0))
        printf("YES\n");
    else 
        printf("NO\n");
 }

有一个大小为N*M的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里总共有多少水洼？（八连通指的是下图中相对w的*部分）

***
*w*
***

样例：

输入

从任意的w开始，不停的把临接的部分用‘.’代替。一次dfs后与初始的这个w连接的所有w就都被替换成了‘.’，因此知道图中不再存在w为止，总共进行dfs的次数就是答案了。

int N, M;
char field[MAX-N][MAX-M];

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 = x+dx, ny = y+dy;
            if(0<=nx && nx<N && 0<=ny && ny<M && field[nx][ny] == 'w')    dfs(nx, ny)
        }
    }
   return ;
}



void solve(){
    int res = 0;
    for(int i=0; i<N; i++){
        for(int j = 0; j<M; j++){
            if(field[i][j] == 'w'){
                dfs(i, j);
                res++;
            }
        }
    }

        printf("%d", res);
}

5. 宽度优先搜索

宽度优先搜索也是搜索的一种手段。宽度优先搜索总是先搜索距离初始状态近的状态。也就是说，他是按照开始状态->只许一次就可以到达的所有状态->只需两次转移就可以到达的所有状态......这样的顺序进行搜索。

样例：迷宫的最短路径

给定一个大小为N*M的迷宫，迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动到终点。

const int INF = 100000000;

//使用pair表示状态时， 使用typedef会更加方便一些
typedef pair<int , int> p;

//输入
char maze[MAX-N][MAX-M+1];  //表示迷宫的字符串的数组
int N, M;
int sx, sy;    //起点坐标
int gx, gy;    //终点坐标

int d[MAX-N][MAX-M];    //到各个位置的最短距离的数组

//4个方向移动的向量
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};

//求从(sx, sy)到(gx, gy)的最短距离
//如果无法到达，则是INF
int dfs(){
    queue<p> que;
    //把所有的位置都初始化为INF
    for(int i = 0; i< N; i++){
        for(int j = 0; j<M; j++){
            d[i][j] = 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++){
            //移动之后的位置记为(nx,ny)
            int nx = p.first+dx[i], ny = p.second + dy[i];
            //判断是否可以移动以及已经访问过(d[nx][ny]！=INF即为已经访问过)
            if(0<=nx && nx<N &&0<=ny && ny<m && maze[nx][ny]!='#' && d[nx][ny] == INF){
                //可以移动的话，则加入到队列，并且到该位置的距离为到p的距离+1
                que.push(p(nx, ny));
                d[nx][ny] = d[p.first][p.second] + 1;
            }
        }
    }
    return d[gx][gy];
}

void solve(){
    int res = bfs();
    printf("%d\n", res);
}

6. 剪枝

顾名思义，穷竭搜索会把所有可能的解都检查一遍，当解空间非常大时，复杂度也会相应变大。比如n个元素进行排列时状态数共有n！个，复杂度也就成了O（n！）。这样dehu的话，即使n=15计算也会很难较早终止。这里jian简单介绍一下此类情形要如何优化。

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

我们回想一下深度优先搜索的例题“部分和问题”。这个问题中的限制条件如果变成0<=ai<=10的8次方，那么在递归中只要sumchao超过k了，此后无论选择哪些数都不可能让sum等于k，所以此后没有必要继续搜索。