广搜（BFS）学习笔记

(Board First Search)

（图为二叉树的层序遍历）
BFS得到顺序：ABCDEFG

与DFS的区别：

深度优先(优先往深处走)，用的数据结构是栈, 主要是递归实现；
广度优先(优先走最近的)，用的数据结构是队列，主要是迭代实现；

bfs通过检测边发现点，被发现点（但未探索）入队。（被探索是指是否检测过与该点相关联的临近顶点）一个顶点被完全探索当且仅当他的所有边被检测。一个顶点探索完选另一个顶点，被选点应位于被发现但未被探索点队列的队首。待探索点集为空时算法结束。（bfs探索顺序与发现顺序一致，dfs发现后马上探索）

广搜的一般结构如下：

定义一个队列;

起始点入队；

while(队列不空){

队头结点出队;

若它是所求的目标状态,跳出循环;

否则，将它扩展出的子结点,全都入队;

}

若循环中找到目标,输出结果;

否则输出无解;

它的主要特点是：

n 每次队头元素出队时，扩展其全部的子结点，并用队列记录下来。

n 搜索过程没有回溯，是一种牺牲空间换取时间的方法。
————————————————————————————

例题：城市平乱

#include<iostream>  
#include<cstring>  
#include<queue>  
using namespace std;  
int city[1005][1005];  
struct army  
{  
    bool ishave;  
    int len;  
}armys[1005];  
bool visited[1005];  
int bfs(int Q,int M)  
{  
    int sum=999999999,temp=0;  
    queue<int> que;  
    memset(visited,0,sizeof(visited));  
    que.push(Q);  
    visited[Q]=1;  
    while(!que.empty())  
    {  
        temp=que.front();  
        for (int i=1;i<=M;i++)  
        {  
            if(!visited[i] && city[temp][i])  
            {  
                visited[i]=1;  
                que.push(i);  
                armys[i].len +=city[temp][i]+armys[temp].len;  
                if(armys[i].ishave && sum>armys[i].len) sum=armys[i].len;  
            }  
        }  
        que.pop();  
    }  
    return sum;  
}  
int main()  
{  
    int T,N,M,P,Q,temp,a,b,c;  
    cin>>T;  
    while(T--)  
    {  
        memset(armys,0,sizeof(armys));  
        memset(city,0,sizeof(city));  
        cin>>N>>M>>P>>Q;  
        for (int i=0;i<N;i++)  
        {  
            cin>>temp;  
            armys[temp].ishave=1;  
        }  
        for (int i=0;i<P;i++)  
        {  
            cin>>a>>b>>c;  
            if(city[a][b]>c || city[a][b] ==0)  
            {  
                city[a][b]=c;  
                city[b][a]=c;  
            }  
        }  
        cout<<bfs(Q,M)<<endl;  
    }  
    return 0;  
}  

参考资料：简单的说一下广搜算法 by 三江小渡