c++：广度优先搜索、深度优先搜索oj（hnust）

深度优先搜索

输入

输入的第一行是两个整数，分别是图的总顶点数n和总边数e

第二行是n个空格分开的字符串，是顶点的名字，依次对应编号0~n-1。

随后有e行，每行两个空格分开的顶点名字，表示一条边的两个顶点。

具体见样例。

输出

输出图的DFS序列，遍历次序按教材，每个顶点后面跟一个空格。

具体见样例。

样例输入

8 9
v1 v2 v3 v4 v5 v6 v7 v8
v1 v2
v1 v3
v2 v4
v2 v5
v3 v6
v3 v7
v4 v8
v5 v8
v6 v7

样例输出

v1 v2 v4 v8 v5 v3 v6 v7 

实现代码：

#include<bits/stdc++.h>
using namespace std;
 
int main(int argc, char const *argv[])
{
    int n , e;
    cin >> n >> e;  // 输入 ： 8 9
 
    string nodes[n];
    for (int i = 0; i < n; ++i)  // 输入： v1 v2 v3 v4 v5 v6 v7 v8
    {
        cin >> nodes[i];
    }
 
    map <string , int > location;
    for (int i = 0; i < n; ++i)   //排序数组
    {
        location[nodes[i]] = i;
    }
 
    map<string ,std::vector<string> > G;  //创建无向图
    for (int i = 0; i < e; ++i)
    {
        string l , r;
        cin >> l >> r;
        G[l].push_back(r);
        G[r].push_back(l);
    }
 
    for (int i = 0; i < n; ++i)  //对无向图的排序
    {
        int j = G[nodes[i]].size();
        for (int p = 0; p < j; ++p)
        {
            for (int q = 0; q < j; ++q)
            {
                if(location[G[nodes[i]][q]] > location[G[nodes[i]][p]])
                {
                    swap(G[nodes[i]][q],G[nodes[i]][p]);
                    // string temp;
                    // temp = G[nodes[i]][q];
                    // G[nodes[i]][q] = G[nodes[i]][p];
                    // G[nodes[i]][p] = temp;
                }
            }
        }
    }
 
    map<string,bool > vis; //是否被访问
    stack <string > s;
    s.push(nodes[0]);
    vis[nodes[0]] = true;
    cout << nodes[0] << " " ;
 
    while(s.size())
    {
        string curr;
        curr = s.top();
        bool flag = 0;
        for(auto next : G[curr])
        {
            // if(vis[next])
            // {
            // }
            if(!vis[next])
            {
                vis[next] = true;
                s.push(next);
                flag = 1;
                 
                // rev[r++] = curr;
                cout << next << " ";
                break;
            }
        }
        if(flag == 0)
        {
            s.pop();
        }
    }
    return 0;
}

总结：

• 第一次交是没有进行排序，所以没有按照输入第二行的次序进行输出，按照第三行往后的输入次序进行输出，得到的结果不正确。

广度优先搜索

输入

输入的第一行是两个整数，分别是图的总顶点数n和总边数e

第二行是n个空格分开的字符串，是顶点的名字，依次对应编号0~n-1。

随后有e行，每行两个空格分开的顶点名字，表示一条边的两个顶点。

具体见样例。

输出

输出图的DFS序列，遍历次序按教材，每个顶点后面跟一个空格。

具体见样例。

样例输入

8 9
v1 v2 v3 v4 v5 v6 v7 v8
v1 v2
v1 v3
v2 v4
v2 v5
v3 v6
v3 v7
v4 v8
v5 v8
v6 v7

样例输出

v1 v2 v3 v4 v5 v6 v7 v8 

实现代码：

#include<bits/stdc++.h>
using namespace std;
 
int main(int argc, char const *argv[])
{
    map < string , std::vector<string> >  G;
    int n ,e;
    cin>> n >> e;  //输入：8 9
 
    string nodes[n];
    for (int i = 0; i < n; ++i)
    {
        cin >> nodes[i];  //输入：v1 v2 v3 v4 v5 v6 v7 v8
    }
 
    map <string , int > location;
    for (int i = 0; i < n; ++i)   //排序数组
    {
        location[nodes[i]] = i;
    }
 
    for (int i = 0; i < e; ++i)  //创建无向图
    {
        string l,r;
        cin >> l >> r;
        G[l].push_back(r);
        G[r].push_back(l);
    }
 
    for (int i = 0; i < n; ++i)  //对无向图的排序
    {
        int j = G[nodes[i]].size();
        for (int p = 0; p < j; ++p)
        {
            for (int q = 0; q < j; ++q)
            {
                if(location[G[nodes[i]][q]] > location[G[nodes[i]][p]])
                {
                    string temp;
                    temp = G[nodes[i]][q];
                    G[nodes[i]][q] = G[nodes[i]][p];
                    G[nodes[i]][p] = temp;
                }
            }
        }
    }
 
    map < string , bool > vis;  //是否被访问
    queue < string > q;
    q.push(nodes[0]);
    vis[nodes[0]] = true;
    // string rev[n];
    // int r = 0;
 
    while(q.size())
    {
        string curr;
        curr = q.front();  q.pop();
        // rev[r++] = curr;
        cout << curr << " ";
 
        for(auto next : G[curr])
        {
            if(!vis[next])
            {
                vis[next] = true;
                q.push(next);
            }
        }
    }
    return 0;
}

总结：

• 用队列实现BFS，用栈实现DFS。