淺談DFS,BFS,IDFS,A*等算法

搜索是編程的基礎，是必須掌握的技能。——王主任

搜索分爲盲目搜索和啓發搜索

下面列舉OI經常使用的盲目搜索：

1. dijkstra
2. SPFA
3. bfs
4. dfs
5. 雙向bfs
6. 迭代加深搜索(IDFS)

下面列舉OI經常使用的啓發搜索：

1. 最佳優先搜索(A)
2. A*
3. IDA*

那麼什麼是盲目，什麼是啓發？

舉個例子，假如你在學校操場，老師叫你去國旗那集合，你會怎麼走？
假設你是瞎子，你看不到周圍，那若是你運氣差，那你可能須要把整個操場走完才能找到國旗。這即是盲目式搜索，即便知道目標地點，你可能也要走完整個地圖。
假設你眼睛沒問題，你看獲得國旗，那咱們只須要向着國旗的方向走就好了，咱們不會傻到往國旗相反反向走，那沒有意義。
這種有目的的走法，便被稱爲啓發式的。

左圖爲bfs，右圖爲A

提供一個搜索可視化的連接https://qiao.github.io/PathFinding.js/visual/

搜索算法淺談

DFS

    基礎中的基礎，幾乎全部題均可以出一檔指數級複雜度暴力分給DFS，同時他的實現也是目錄中提到的全部搜索算法中最簡單的

dfs的核心思想是：不撞南牆不回頭    孫學鳳:物理人不撞南牆

舉個例子：

你如今在一號點，你想找到樹中與一號點連通的每個點
那麼咱們考慮按照深度優先的順序去遍歷這棵樹，即，假設你當前在點x，若是和x連邊的點中有一個點y，知足y比x深，即y是x的兒子，而且y尚未被訪問過，那麼咱們就走到y，若是有多個y知足條件，咱們走到其中任意一個
若是沒有y知足條件，咱們返回x的父親
按照這個順序，咱們就能夠訪問到每一個節點，而且每條邊會剛好被走兩次（從父親到兒子一次，從兒子到父親一次）

因爲dfs的特性，它有時候會很是的浪費時間，爲何呢？
仍是剛纔這張圖：

若是咱們把終點設在10號點，在dfs的過程當中要先搜完一號點及其三個子樹才能到達終點

代碼大致框架：

void dfs(int k){
    if(到達目的地或知足條件)輸出解
    for(int i=1;i<=算符種數;++i){
        保存結果//有時候不須要
        dfs(k+1);
        回溯結果//有時候不須要
    }
}

那麼何時須要回溯呢？
咱們先要了解回溯的目的：

咱們在搜索的過程當中，先選擇一種可能的狀況向前搜索，一旦發現選擇的結果是錯誤的，就退一步從新選擇，這就須要回溯，向前搜索一步以後將狀態恢復成以前的樣子

因此在解題的過程當中要判斷好是否須要回溯

bfs

bfs利用了一種線性數據結構，隊列

bfs的核心思想是:從廚師節點開始，生成第一層節點，檢查目標節點是否在目標節點中，若沒有再將第一層全部的節點逐一擴展，如此往復知道發現目標節點爲止

咱們再拿出徐瑞帆dalao的圖：

你如今仍是在一號點，你仍是想找到樹中與一號點連通的每個點
咱們初始的時候把一號點推入隊取出隊尾，而後只要當前隊列非空，咱們就取出隊頭元素x，並將隊頭彈出
而後咱們將x的全部兒子推入隊列
對於圖上的狀況，咱們將全部與x相連，而且還沒入過隊的點推入隊列
這樣咱們就可以訪問全部點

代碼大體框架:

void bfs(){
    q.push(head);
    while(!q.empty()){
        temp=q.front;
        q.pop();
        if(temp爲目標狀態)輸出解
        if(temp不合法)continue;
        if(temp合法)q.push(temp+Δ);
    }
}

IDFS

咱們已經學會了dfs和bfs
然而有的問題仍是使咱們沒法進行搜索，由於你要進行搜索的圖多是無限大的，每一個點所連的邊也多是無限多的，這就使得dfs和bfs都失效了，這時候咱們就須要用到idfs
咱們枚舉深搜的時候深度的上限，由於深度上限的限制，圖中的一些邊會被刪掉，而圖就變成了一個有限的圖，咱們就能夠進行dfs了

舉個栗子:

若是用普通的dfs，這顯然是一個無解的狀況，你將會陷入無限的左子樹中

這時，咱們設一個深度d，每次搜到第d層就返回搜其餘的分支。若是在d層沒搜到答案則d++，從頭再搜

然而這個算法有一個很明顯的缺陷，有一些非答案點要重複搜好幾遍，這形成了極大的浪費

因而咱們有了IDA*

A
在看IDA 以前，咱們先了解A*

搜索算法常常運行效率很低，爲了提升效率，咱們可使用A*算法
咱們對每一個點定義一個估價函數f(x)=g(x)+h(x)
g(x)表示從起始點到x的實際代價
h(x)表示估計的從x到結束點的代價，並要求h(x)小於等於從x到結束點的實際代價
那麼每次咱們從可行點集合中找到f(x)最小的x，而後搜索他
這個過程能夠用優先隊列（即堆）實現
這樣的話能夠更快地到達結束點，並保證到達結束點時走的是最優路徑

爲何要求h(x)小於等於實際代價呢？
由於若是h(x)大於實際代價的話，可能以一條非最優的路徑走到結束點，致使答案變大

舉個栗子:用A*作的八數碼難題

#include<map>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
int dx[]={-1,0,0,1},dy[]={0,-1,1,0};
int final[]={-1,0,1,2,5,8,7,6,3};
struct node
{
    int state,g,h;
    node(int _state,int _g)
    {
        state=_state;
        g=_g;
        h=0;
        int tmp=state;
        for(int i=8;i>=0;i--)
        {
            int a=tmp%10;tmp/=10;
            if(a!=0)h+=abs((i/3)-(final[a]/3))+abs((i%3)-(final[a]%3));
        }
    }
};
bool operator<(node x,node y)
{
    return x.g+x.h>y.g+y.h;
}
priority_queue<node>q;
map<int,bool>vis;
int main()
{
    int n;
    cin>>n;
    q.push(node(n,0));
    vis[n]=1;
    while(!q.empty())
    {
        node u=q.top();
        int c[3][3],f=0,g=0,n=u.state;q.pop();
        if(u.state==123804765)
        {
            cout<<u.g<<endl;
            return 0;
        }
        for(int i=2;i>=0;i--)
        for(int j=2;j>=0;j--)
        {
            c[i][j]=n%10,n/=10;
            if(!c[i][j])f=i,g=j;
        }
        for(int i=0;i<4;i++)
        {
            int nx=f+dx[i],ny=g+dy[i],ns=0;
            if(nx<0||ny<0||nx>2||ny>2)continue;
            swap(c[nx][ny],c[f][g]);
            for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
            ns=ns*10+c[i][j];
            if(!vis.count(ns))
            {
                vis[ns]=1;
                q.push(node(ns,u.g+1));
            }
            swap(c[nx][ny],c[f][g]);
        }
    }
}

這是bfs作法

這是A*作法

很明顯，A*比bfs快多了

值得注意的是，A*只能在有解的狀況下使用

IDA
在進行IDFS的時候，咱們也能夠用A進行搜索

若是在當前深度限制下搜到告終束狀態，咱們就能夠直接輸出答案

代碼大致框架:

//1表明牆，0表明空地，2表明終點
int G[maxn][maxn];
int n, m;
int endx, endy;
int maxd;
const int dx[4] = { -1, 1, 0, 0 };
const int dy[4] = { 0, 0, -1, 1 };
namespace ida
{
    bool dfs(int x, int y, int d);
    inline int h(int x, int y);
    bool ida_star(int x, int y, int d)
    {
        if (d == maxd)                   //是否搜到答案
        {
            if (G[x][y] == 2)
                return true;
            return false;
        }
        int f = h(x, y) + d;          //評估函數
        if (f > maxd)                //maxd爲最大深度
            return false;
    //嘗試向左，向右,向上，向下走
        for (int i = 0; i < 4; i++)
        {
            int next_x = x + dx[i];
            int next_y = y + dy[i];
            if (next_x > n || next_x < 1 || next_y > m || next_y < 1 || G[next_x][next_y] == 1)
                continue;
            if (ida_star(next_x, next_y, d + 1))
                return true;
        }
        return false;
    }
    inline int h(int x, int y)
    {
        return abs(x - endx) + abs(y - endy);
    }
}