圖遍歷算法——DFS、BFS、A*、B*和Flood Fill 遍歷算法大串講

文章出自：http://dsqiu.iteye.com/blog/1689130

圖遍歷算法——DFS、BFS、A*、B*和Flood Fill 遍歷算法大串講

本文內容框架：

§1 圖遍歷DFS和BFS兩種實現

§2 A*算法

§3 B*算法

§4 Flood Fill算法

§5 小結

圖遍歷問題分爲四類：

遍歷完所有的邊而不能有重複，即所謂“一筆畫問題”或“歐拉路徑”；

遍歷完所有的頂點而沒有重複，即所謂“哈密爾頓問題”。

遍歷完所有的邊而可以有重複，即所謂“中國郵遞員問題”；

遍歷完所有的頂點而可以重複，即所謂“旅行推銷員問題”。

 

對於第一和第三類問題已經得到了完滿的解決，而第二和第四類問題則只得到了部分解決。

第一類問題就是研究所謂的歐拉圖的性質，而第二類問題則是研究所謂的哈密爾頓圖的性質。

 

 

 

§1 圖遍歷DFS和BFS兩種實現

 

圖遍歷的矩陣存儲和鄰接表存儲的BFS和DFS實現

╔

矩陣存儲BFS

 

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
queue <int> qu, qq;
int map[100][100], m, n, judge[100], path[100];
void bfs(){//和導論上的染色的方法差不多，judge[0] == 0 時候代表白色節點   在隊列裏面的節點是灰色的 出隊列的是黑色的。
    int w, s,t,i, j;
    while(true){
        s = qu.size();
        if(!s)return;
        while(s--){
            t = qu.front();
            for(i = 0; i < n; i++){
                if(map[t][i] && !judge[i]){
                    judge[i] = true;
                    qu.push(i);
                    path[i] = t;//記錄寬度優先搜索樹中的當前節點的父親
                    //printf("path[%d] = %d\n", i, t);
                }
            }
            qu.pop();
        }
    }
}
void printpath(int n){ //遞歸的輸出路徑
    if(path[n] == -1)printf("%d ", n);
    else{
        printpath(path[n]);
        printf("%d ", n);
    }
}
int main(){
    freopen("bfs.in", "r", stdin);
    freopen("bfs.out", "w", stdout);
    int i, j, u, v;
    while(scanf("%d%d", &n, &m) != -1){
        memset(judge, 0, sizeof(judge));
        for(i = 0; i < m; i++){
            scanf("%d%d", &u, &v);
            map[u][v] = map[v][u] = 1;
        }
        judge[0] = true;qu = qq;
        qu.push(0);memset(path, -1, sizeof(path));
        bfs();
        for(i = 1; i < n; i++){
            printf("from 0 to %d : ", i);
            printpath(i);puts("");
        }
    }
    return 0;
}

 

鏈表存儲BFS

 

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
queue<int> qu, qq;
struct e{
    int v;
    e* next;
};
e* edge[100];int m, n, judge[100], path[100];
void bfs(){
    int w, i, j, t, s;e* l;
    while(true){
        s = qu.size();
        if(!s)return;
        while(s--){
            w = qu.front();
            l = edge[w];
            while(l){
                t = l->v;
                if(!judge[t]){
                    judge[t] = true;
                    qu.push(t);
                    path[t] = w;
                }
                l = l->next;
            }
            qu.pop();
        }
    }
}
void printpath(int x){
    if(path[x] == -1)printf("%d ", x);
    else{
        printpath(path[x]);
        printf(" %d", x);
    }
}
int main(){  //個人不推薦動態開闢存儲空間，建議靜態。
    freopen("bfs_link.in", "r", stdin);
    freopen("bfs_link.out", "w", stdout);
    int u, v, i, j;e* node;
    while(scanf("%d%d", &n, &m) != -1){
        memset(judge, 0, sizeof(judge));
        memset(path, -1, sizeof(path));
        for(i = 0; i < m; i++){
            scanf("%d%d", &u, &v);
            node = new e;
            node->v = v;
            node->next = edge[u];
            edge[u] = node;
            node = new e;
            node->v = u;
            node->next = edge[v];
            edge[v] = node;
        }
        judge[0] = true;qu = qq;qu.push(0);
        bfs();
        for(i = 1; i < n; i++){
            printf("path from 0 to %d : ", i);
            printpath(i);puts("");
        }
    }
    return 0;
}

 

矩陣存儲DFS

 

#include <stdio.h>
#include <string.h>
int map[100][100], m, n, d[100], f[100], time, path[100];
bool judge[100];
void dfs(int v){
    int i;judge[v] = true;
    time++;d[v] = time;//開始時間
    for(i = 0; i < n; i++){
        if(map[v][i] && !judge[i]){
            path[i] = v;//記錄深度優先搜索樹中的父親節點
            dfs(i);
        }
    }
    time++;f[v] = time;//結束時間
}

void printpath(int v){
    if(path[v] == -1)printf("%d ", v);
    else{
        printpath(path[v]);
        printf(" %d", v);
    }
}

int main(){
    freopen("dfs_m.in", "r", stdin);
    freopen("dfs_m.out", "w", stdout);
    int i, j, u, v;
    while(scanf("%d%d", &n, &m) != -1){
        memset(map, 0, sizeof(map));
        memset(judge, 0, sizeof(judge));
        memset(path, -1, sizeof(path));
        for(i = 0; i < m; i++){
            scanf("%d%d", &u, &v);
            map[u][v] = map[v][u] = true;
        }
        time = 0;dfs(0);
        for(i = 0; i < n; i++){
            printf("d[%d] = %d   f[%d] = %d\n", i, d[i], i, f[i]);
        }
        for(i = 1; i < n; i++){
            printf("path from 0 to %d : ");
            printpath(i);puts("");
        }
    }
    return 0;
}

 

鏈表存儲BFS

 

#include <stdio.h>
#include <string.h>
struct e{
    int v;
    e* next;
};
e* link[100];e edge[10000];//靜態的
int m, n, el, judge[100], d[100], f[100], time, path[100];
void dfs(int v){
    int i, t;e* l;
    judge[v] = true;
    time++;d[v] = time;
    l = link[v];
    while(l){
        t = l->v;
        if(!judge[t]){
            judge[t] = true;
            path[t] = v;
            dfs(t);
        }
        l = l->next;
    }
    time++;f[v] = time;
}

void printpath(int v){
    if(path[v] == -1)printf("%d", v);
    else{
        printpath(path[v]);
        printf(" %d", v);
    }
}

int main(){
    freopen("dfs_link.in", "r", stdin);
    freopen("dfs_link.out", "w", stdout);
    int i, j, u, v;
    while(scanf("%d%d", &n, &m) != -1){
        memset(judge, 0, sizeof(judge));
        memset(link, 0, sizeof(edge));
        memset(path, -1, sizeof(path));
        for(i = 0, el = 0; i < m; i++){
            scanf("%d%d", &u, &v);
            edge[el].v = v;
            edge[el].next = link[u];
            link[u] = &edge[el++];
            edge[el].v = u;
            edge[el].next = link[v];
            link[v] = &edge[el++];
        }time = 0;
        for(i = 0; i < n; i++){
            if(!judge[i])dfs(i);
        }
        for(i = 0; i < n; i++){
            printf("d[%d] = %d  f[%d] = %d\n", i, d[i], i, f[i]);
        }
        for(i = 1; i < n; i++){
            printf("path form 0 to %d : ", i);
            printpath(i);puts("");
        }
    }
    return 0;
}

  ╝①

 

§2 A*算法

 

A*算法

 

A*算法是一種常用的啓發式搜索算法。

╔
在A*算法中，一個結點位置的好壞用估價函數來對它進行評估。A*算法的估價函數可表示爲： 
f'(n) = g'(n) + h'(n) 
這裏，f'(n)是估價函數，g'(n)是起點到終點的最短路徑值（也稱爲最小耗費或最小代價），h'(n)是n到目標的最短路經的啓發值。由於這個f'(n)其實是無法預先知道的，所以實際上使用的是下面的估價函數：
f(n) = g(n) + h(n) 
其中g(n)是從初始結點到節點n的實際代價，h(n)是從結點n到目標結點的最佳路徑的估計代價。在這裏主要是h(n)體現了搜索的啓發信息，因爲g(n)是已知的。用f(n)作爲f'(n)的近似，也就是用g(n)代替g'(n)，h(n)代替h'(n)。這樣必須滿足兩個條件：（1）g(n)>=g'(n)（大多數情況下都是滿足的，可以不用考慮），且f必須保持單調遞增。（2）h必須小於等於實際的從當前節點到達目標節點的最小耗費h(n)<=h'(n)。第二點特別的重要。可以證明應用這樣的估價函數是可以找到最短路徑的。

A*算法的具體步驟
A*算法基本上與廣度優先算法相同，但是在擴展出一個結點後，要計算它的估價函數，並根據估價函數對待擴展的結點排序，從而保證每次擴展的結點都是估價函數最小的結點。
1）建立一個隊列，計算初始結點的估價函數f，並將初始結點入隊，設置隊列頭和尾指針。
2）取出隊列頭（隊列頭指針所指）的結點，如果該結點是目標結點，則輸出路徑，程序結束。否則對結點進行擴展。 
3）檢查擴展出的新結點是否與隊列中的結點重複，若與不能再擴展的結點重複（位於隊列頭指針之前），則將它拋棄；若新結點與待擴展的結點重複（位於隊列頭指針之後），則比較兩個結點的估價函數中g的大小，保留較小g值的結點。跳至第五步。
4）如果擴展出的新結點與隊列中的結點不重複，則按照它的估價函數f大小將它插入隊列中的頭結點後待擴展結點的適當位置，使它們按從小到大的順序排列，最後更新隊列尾指針。
5）如果隊列頭的結點還可以擴展，直接返回第二步。否則將隊列頭指針指向下一結點，再返回第二步。

╝②

 

A*算法圖解

╔

 

 如圖所示簡易地圖, 其中綠色方塊的是起點 (用 A 表示), 中間藍色的是障礙物, 紅色的方塊 (用 B 表示) 是目的地. 爲了可以用一個二維數組來表示地圖, 我們將地圖劃分成一個個的小方塊。

 

 

 

二維數組在遊戲中的應用是很多的, 比如貪吃蛇和俄羅斯方塊基本原理就是移動方塊而已. 而大型遊戲的地圖, 則是將各種"地貌"鋪在這樣的小方塊上。

 

 

F = G + H，               

G 表示從起點 A 移動到網格上指定方格的移動耗費 (可沿斜方向移動)。 

H 表示從指定的方格移動到終點 B 的預計耗費 (H 有很多計算方法, 這裏我們設定只可以上下左右移動)。

   我們假設橫向移動一個格子的耗費爲10, 爲了便於計算, 沿斜方向移動一個格子耗費是14. 爲了更直觀的展示如何運算 F，G，H, 圖中方塊的左上角數字表示 F, 左下角表示 G, 右下角表示 H。 看看上圖是否跟你心裏想的結果一樣？

 將上圖A周圍的方塊全部放入隊列，取出F值最小的方塊C，看看 C 下面的那個格子, 它目前的 G 是14, 如果通過 C 到達它的話, G將會是 10 + 10, 這比 14 要大, 因此我們什麼也不做（上面步驟3））。

以C爲中心結點，擴展新結點 ，並進入隊列（上面步驟4））。

直到最終找到終點B，上面淺藍色邊緣的方塊是移動過的地點（實際走過的地方），淺綠色邊緣的方塊是還在隊列中的方塊。

╝③  

A*算法實現

╔

 

/*
 * file: astar_algorithm.h
 * author: MulinB@HUST
 * date: 2010-10-10
 * modified: 2012-05-09
 * A-star algorithm implemented in C. Only for study.
 */
#ifndef _ASTAR_ALGORITHM_H
#define _ASTAR_ALGORITHM_H
#include <math.h>
#define M  6
#define N  8
//map marks
#define  AVAIL     0
#define  UNAVAIL  -1
#define  START   100
#define  END     111
#define  ROAD     10
#define GET_F(X)  (X->G + X->H)
typedef struct Node
{
    //for node itself
    int type; //node type
    int i; //i index
    int j; //j index
    //for A star algorithm
    double G; //past road cost
    double H; //heuristic, F = G + H
    struct Node* parent; //parent node, used for trace road
    struct Node* next; //only used for open and close list
}Node;

//==========================open close list operation================
Node* open_list;
Node* close_list;
void init_openlist()
{
    open_list = NULL;
}
void init_closelist()
{
    close_list = NULL;
}
void destroy_openlist()
{
    Node* q;
    Node* p = open_list;
    while (p != NULL)
    {
        q = p->next;
        free(p);
        p = q;
    }
}
void destroy_closelist()
{
    Node* q;
    Node* p = close_list;
    while (p != NULL)
    {
        q = p->next;
        free(p);
        p = q;
    }
}
void insert_into_openlist(Node* new_node) //insert and sort by F
{
    Node* p;
    Node* q;
    if (open_list == NULL)
    {
        open_list = new_node; //insert as the first
        return;
    }
    p = open_list;
    while (p != NULL)
    {
        q = p;
        p = p->next;
        if (p == NULL)
        {
            q->next = new_node; //insert as the last
            return;
        }
        else if (GET_F(new_node) < GET_F(p))
        {
            q->next = new_node; //insert before p, sorted
            new_node->next = p;
            return;
        }
    }

}
void insert_into_closelist(Node* new_node) //just insert before head
{
    if (close_list == NULL)
    {
        close_list = new_node; //insert as the first
        return;
    }
    else
    {
        new_node->next = close_list; //insert before head
        close_list = new_node;
        return;
    }
}
Node* find_node_in_list_by_ij(Node* node_list, int di, int dj)
{
    Node* p = node_list;
    while (p)
    {
        if (p->i == di && p->j == dj)
            return p;
        p = p->next;
    }
    return NULL;
}
Node* pop_firstnode_from_openlist() //get the minimum node sorted by F
{
    Node* p = open_list;
    if (p == NULL)
    {
        return NULL;
    }
    else
    {
        open_list = p->next;
        p->next = NULL;
        return p;
    }
}
void remove_node_from_openlist(Node* nd) //just remove it, do not destroy it
{
    Node* q;
    Node* p = open_list;
    if (open_list == nd)
    {
        open_list = open_list->next;
        return;
    }
    while (p)
    {
        q = p;
        p = p->next;
        if (p == nd) //found
        {
            q->next = p->next;
            p->next = NULL;
            return;
        }
    }
}
void remove_node_from_closelist(Node* nd) //just remove it, do not destroy it
{
    Node* q;
    Node* p = close_list;
    if (close_list == nd)
    {
        close_list = close_list->next;
        return;
    }
    while (p)
    {
        q = p;
        p = p->next;
        if (p == nd) //found
        {
            q->next = p->next;
            p->next = NULL;
            return;
        }
    }
}
//===================================================================
//=======================calculate H, G =============================
//calculate Heuristic value
//(reimplemented when porting a star to another application)
double calc_H(int cur_i, int cur_j, int end_i, int end_j)
{
    return (abs(end_j - cur_j) + abs(end_i - cur_i)) * 10.0; //the heuristic
}
//calculate G value
//(reimplemented when porting a star to another application)
double calc_G(Node* cur_node)
{
    Node* p = cur_node->parent;
    if (abs(p->i - cur_node->i) + abs(p->j - cur_node->j) > 1)
        return 14.0 + p->G; //the diagonal cost is 14
    else
        return 10.0 + p->G; //the adjacent cost is 10
}
void init_start_node(Node* st, int si, int sj, int ei, int ej)
{
    memset(st, 0, sizeof(Node));
    st->type = START;
    st->i = si;
    st->j = sj;
    st->H = calc_H(si, sj, ei, ej);
    st->G = 0;
}
void init_end_node(Node* ed, int ei, int ej)
{
    memset(ed, 0, sizeof(Node));
    ed->type = END;
    ed->i = ei;
    ed->j = ej;
    ed->H = 0;
    ed->G = 9999; //temp value
}
void init_pass_node(Node* pd, int pi, int pj)
{
    memset(pd, 0, sizeof(Node));
    pd->type = AVAIL;
    pd->i = pi;
    pd->j = pj;
}
//check the candidate node (i,j) when extending parent_node
int check_neighbor(int map[][N], int width, int height,
    int di, int dj, Node* parent_node, Node* end_node)
{
    Node* p;
    Node* temp;
    double new_G;
    if (di < 0 || dj < 0 || di > height-1 || dj > width-1)
        return UNAVAIL;
    //1. check available
    if (map[di][dj] == UNAVAIL)
        return UNAVAIL;
    //2. check if existed in close list
    p = find_node_in_list_by_ij(close_list, di, dj);
    if (p != NULL)
    {
        //found in the closed list, check if the new G is better, added 2012-05-09
        temp = p->parent;
        p->parent = parent_node;
        new_G = calc_G(p);
        if (new_G >= p->G)
        {
            p->parent = temp; //if new_G is worse, recover the parent
        }
        else
        {
            //the new_G is better, remove it from close list, insert it into open list
            p->G = new_G;
            remove_node_from_closelist(p); //remove it
            insert_into_openlist(p); //insert it, sorted
        }
        return AVAIL;
    }
    //3. check if existed in open list
    p = find_node_in_list_by_ij(open_list, di, dj); //in open list
    if (p != NULL)
    {
        //found in the open list, check if the new G is better
        temp = p->parent;
        p->parent = parent_node;
        new_G = calc_G(p);
        if (new_G >= p->G)
        {
            p->parent = temp; //if new_G is worse, recover the parent
        }
        else
        {
            //the new_G is better, resort the list
            p->G = new_G;
            remove_node_from_openlist(p); //remove it
            insert_into_openlist(p); //insert it, sorted
        }
        return AVAIL;
    }

    //4. none of above, insert a new node into open list
    if (map[di][dj] == END)
    {
        //4~. check if it is end node
        end_node->parent = parent_node;
        end_node->G = calc_G(end_node);
        insert_into_openlist(end_node); //insert into openlist
        return AVAIL;
    }
    else
    {
        //4~~. create a new node
        p = malloc(sizeof(Node));
        init_pass_node(p, di, dj);
        p->parent = parent_node;
        p->H = calc_H(di, dj, end_node->i, end_node->j);
        p->G = calc_G(p);
        insert_into_openlist(p); //insert into openlist
        return AVAIL;
    }
}
//extend the current node on the map
//(reimplemented when porting a star to another application)
void extend_node(Node* cd, int map[][N], int width, int height, Node* end_node)
{
    int up_status, down_status, left_status, right_status;
    int ci, cj; //cur node i, j
    int ti, tj; //temp i, j
    ci = cd->i;
    cj = cd->j;
    //1. up
    ti = ci - 1;
    tj = cj;
    up_status = check_neighbor(map, width, height, ti, tj, cd, end_node);
    //2. down
    ti = ci + 1;
    tj = cj;
    down_status = check_neighbor(map, width, height, ti, tj, cd, end_node);
    //3. left
    ti = ci;
    tj = cj - 1;
    left_status = check_neighbor(map, width, height, ti, tj, cd, end_node);
    //4. right
    ti = ci;
    tj = cj + 1;
    right_status = check_neighbor(map, width, height, ti, tj, cd, end_node);
    //5. leftup
    ti = ci - 1;
    tj = cj - 1;
    if (up_status == AVAIL && left_status == AVAIL)
        check_neighbor(map, width, height, ti, tj, cd, end_node);
    //6. rightup
    ti = ci - 1;
    tj = cj + 1;
    if (up_status == AVAIL && right_status == AVAIL)
        check_neighbor(map, width, height, ti, tj, cd, end_node);
    //7. leftdown
    ti = ci + 1;
    tj = cj - 1;
    if (down_status == AVAIL && left_status == AVAIL)
        check_neighbor(map, width, height, ti, tj, cd, end_node);
    //8. rightdown
    ti = ci + 1;
    tj = cj + 1;
    if (down_status == AVAIL && right_status == AVAIL)
        check_neighbor(map, width, height, ti, tj, cd, end_node);

}

//=======================search algorithm======================================
/*
A*方法總結 (from http://www.policyalmanac.org/games/aStarTutorial.htm):
1. 把起始格添加到開啓列表。
2. 重複如下的工作：
  a) 尋找開啓列表中F值最低的格子。我們稱它爲當前格。
  b) 把它切換到關閉列表。
  c) 對相鄰的8格中的每一個？
    * 如果它不可通過或者已經在關閉列表中，略過它。反之如下。(MulinB 2012-05-09 按：在關閉列表中是否也應該檢查它，看是否可以獲得更低的G值?? ref: http://theory.stanford.edu/~amitp/GameProgramming/ImplementationNotes.html )
    * 如果它不在開啓列表中，把它添加進去。把當前格作爲這一格的父節點。記錄這一格的F,G,和H值。
    * 如果它已經在開啓列表中，用G值爲參考檢查新的路徑是否更好。更低的G值意味着更好的路徑。
      如果是這樣，就把這一格的父節點改成當前格，並且重新計算這一格的G和F值。
      如果你保持你的開啓列表按F值排序，改變之後你可能需要重新對開啓列表排序。
  d) 停止，當你
    * 把目標格添加進了關閉列表(註解)，這時候路徑被找到，或者
    * 沒有找到目標格，開啓列表已經空了。這時候，路徑不存在。
3. 保存路徑。從目標格開始，沿着每一格的父節點移動直到回到起始格。這就是你的路徑。
*/
//search a road on a map, return node_list
Node* a_star_search(int map[M][N], int width, int height,
                    int start_i, int start_j, int end_i, int end_j)
{
    Node* cur_node;
    Node* start_node;
    Node* end_node;
    //create start and end node
    start_node = malloc(sizeof(Node));
    init_start_node(start_node, start_i, start_j, end_i, end_j);
    end_node = malloc(sizeof(Node));
    init_end_node(end_node, end_i, end_j);

    //init open and close list
    init_openlist();
    init_closelist();
    //put start_node into open list
    insert_into_openlist(start_node);

    //start searching
    while (1)
    {
        cur_node = pop_firstnode_from_openlist(); //it has the minimum F value
        if (cur_node == NULL || cur_node->type == END)
        {
            break; //found the road or no road found
        }

        extend_node(cur_node, map, width, height, end_node); //the key step!!
        insert_into_closelist(cur_node);
    }
    //you can track the road by the node->parent
    return cur_node;
}

#endif /* file end */

 ╝④

 

 

B*算法

╔

B* 尋路算法又叫Branch Star 分支尋路算法，且與A*對應，本算法適用於遊戲中怪物的自動尋路，其效率遠遠超過A*算法，經過測試，效率是普通A*算法的幾十上百倍。 
通過引入該算法，一定程度上解決了遊戲服務器端無法進行常規尋路的效率問題，除非服務器端有獨立的AI處理線程，否則在服務器端無法允許可能消耗大量時間的尋路搜索，即使是業界普遍公認的最佳的A*，所以普遍的折中做法是服務器端只做近距離的尋路，或通過導航站點縮短A*的範圍。 

 

 

§3 B*算法

B*算法原理 
本算法啓發於自然界中真實動物的尋路過程，並加以改善以解決各種阻擋問題(有點類似蟻羣算法）。 
前置定義： 
1、探索節點： 
爲了敘述方便，我們定義在尋路過程中向前探索的節點（地圖格子）稱爲探索節點，起始探索節點即爲原點。（探索節點可以對應爲A*中的開放節點）。
2、自由的探索節點： 
探索節點朝着目標前進，如果前方不是阻擋，探索節點可以繼續向前進入下一個地圖格子，這種探索節點我們稱爲自由探索節點； 
3、繞爬的探索節點： 
探索節點朝着目標前進，如果前方是阻擋，探索節點將試圖繞過阻擋，繞行中的探索節點我們成爲繞爬的探索節點； 
B*算法流程 
1、起始，探索節點爲自由節點，從原點出發，向目標前進； 
2、自由節點前進過程中判斷前面是否爲障礙， 
      a、不是障礙，向目標前進一步，仍爲自由節點； 
      b、是障礙，以前方障礙爲界，分出左右兩個分支，分別試圖繞過障礙，這兩個分支節點即成爲兩個繞爬的探索節點； 
3、繞爬的探索節點繞過障礙後，又成爲自由節點，回到2）； 
4、探索節點前進後，判斷當前地圖格子是否爲目標格子，如果是則尋路成功，根據尋路過程構造完整路徑； 
5、尋路過程中，如果探索節點沒有了，則尋路結束，表明沒有目標格子不可達； 

B*算法圖解演示 
     
    


B*算法與A*算法的性能比較 
尋路次數比較（5秒鐘尋路次數） 

 

╝⑤

 

§4 Flood Fill算法

 

Flood Fill算法

 

Flood Fill算法是計算機圖形學和數字圖像處理的一個填充算法，其實就是從一點開始向四面周圍尋找點填充遍歷，原理和BFS很相似，當然也可以像DFS一樣的遍歷。

 

Flood Fill 算法圖解演示

Flood Fill算法實現

說的Flood Fill算法的實現不得不提Lode's Computer Graphics Tutorial。該算法可以通過遞歸或者是stack來完成，下面只附上4-Way Recurisive Method:

 

//Recursive 4-way floodfill, crashes if recursion stack is full
void floodFill4(int x, int y, int newColor, int oldColor)
{
    if(x >= 0 && x < w && y >= 0 && y < h && screenBuffer[x][y] == oldColor && screenBuffer[x][y] != newColor)
    {
        screenBuffer[x][y] = newColor; //set color before starting recursion

        floodFill4(x + 1, y,     newColor, oldColor);
        floodFill4(x - 1, y,     newColor, oldColor);
        floodFill4(x,     y + 1, newColor, oldColor);
        floodFill4(x,     y - 1, newColor, oldColor);
    }
}

 

 

 

 

§5 小結

這篇文章摘錄了圖算法最基本的BFS和DFS的實現以及A*、B*和Flood Fill的基本原理，由於原理不是十分難懂又有圖解過程，所以可以一次性掌握原理（雖然文字介紹相當簡要，不過好像也沒有什麼要說的），剩下的動手的問題。如果你有任何建議或者批評和補充，請留言指出，不勝感激，更多參考請移步互聯網。

 

 

 

參考：

①MemoryGarden：http://www.cppblog.com/MemoryGarden/articles/97979.html

②阿凡盧：http://www.cnblogs.com/luxiaoxun/archive/2012/08/05/2624115.html

③ Create Chen： http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html

④在迷茫中尋找四葉草 --MulinB的技術博客：http://blog.csdn.net/mulinb/article/details/5939225

⑤inysong:http://qinysong.iteye.com/blog/678941