BFS、DFS

最近碰到了很多搜索的题，重新整理一次博客叭～

DFS（深度优先搜索）
需要一个栈，因为每次都是搜到之后不停的往下搜，符合先进先出。但是一般来说不用栈，而是直接通过函数的递归就行了。
代码：

bool vis[110];
int N;

void DFS(int u)
{
    int len;

    vis[u]=1;
    len=E[u].size();

    for(int i=0;i<len;++i)
        if(vis[E[u][i]]==0)
            DFS(E[u][i]);
}

DFS主要的特性是深度优先，总是不停的往下找，走到没路才罢休。就是先找一个点，然后去搜索所有和他相连的点，搜到无路可走为止。以上图为例，先搜1，与1相连的是5，再搜4，再搜6，发现无路可走，返回4去搜3，从3再搜2，发现无路可走返回3，返回4……

再来看BFS
　　比如这个图，如果从1开始进行搜索的话，BFS的步骤就是，先搜索所有和1相连的，也就是2和5被找到了，然后再从2开始搜索和他相连的，也就是3被找到了，然后从5搜，也就是4被找到了，然后从3开始搜索，4被找到了，但是4之前已经被5找到了，所以忽略掉就行。然后3开始搜索，忽略4所以啥都没搜到，然后从4开始，6被找到了。满足先入先出的特点，因此用队列来实现算法
代码：

bool vis[110];            // 记录已经走过的点，防止重复访问。

void BFS(int root,int N)        // N个点的图，从root点开始搜索。
{
    queue <int> que;

    memset(vis,0,sizeof(vis));    // 初始化。
    vis[root]=1;
    que.push(root);

    int u,len;

    while(!que.empty())
    {
        u=que.front();
        que.pop();

        len=E[u].size();
        for(int i=0;i<len;++i)        // 找到和u相连的所有点，存在一个vector里面。
            if(vis[E[u][i]]==0)
            {
                vis[E[u][i]]=1;
                que.push(E[u][i]);
            }
    }
}

至于存图
有三种方法：
1.邻接矩阵
2.vector
3.前向星
复习一下暑假学的前向星

我们输入边的顺序为:

1 2

2 3

3 4

1 3

4 1

1 5

4 5

我们建立边结构体为:

struct Edge

{

     int next;

     int to;

     int w;

};

其中edge[i].to表示第i条边的终点,edge[i].next表示与第i条边同起点的下一条边的存储位置,edge[i].w为边权值.

另外还有一个数组head[],它是用来表示以i为起点的第一条边存储的位置,实际上你会发现这里的第一条边存储的位置其实在以i为起点的所有边的最后输入的那个编号.
初始时head数组清为-1，当edge[i].next==-1时，就是不在有与第i个边同起点的下一条边了
代码：

void add(int u,int v,int w)  
{    
    edge[cnt].to = v;  
    edge[cnt].next = head[u];
    edge[cnt].w = w;  
    head[u] = cnt++;  
}

模拟一下，初始化cnt赋上0
edge[0].to = 2; edge[0].next = -1; head[1] = 0;
edge[1].to = 3; edge[1].next = -1; head[2] = 1;
edge[2].to = 4; edge[2],next = -1; head[3] = 2;
edge[3].to = 3; edge[3].next = 0; head[1] = 3;
edge[4].to = 1; edge[4].next = -1; head[4] = 4;
edge[5].to = 5; edge[5].next = 3; head[1] = 5;
edge[6].to = 5; edge[6].next = 4; head[4] = 6;

cnt每次++，代表这是结构体里的第cnt个边
最终head数组存的就是以第i个数作为起点的最后一条边了

我们在遍历以u节点为起始位置的所有边的时候是这样的: for(int i=head[u];~i;i=edge[i].next) 那么就是说先遍历编号为5的边,也就是head[1],然后就是edge[5].next,也就是编号3的边,然后继续edge[3].next,也 就是编号0的边,可以看出是逆序的.