SDUTOJ2142_数据结构实验之图论二：基于邻接表的广度优先搜索遍历(BFS)

数据结构实验之图论二：基于邻接表的广度优先搜索遍历

Time Limit: 1000 ms Memory Limit: 65536 KiB

Submit Statistic

Problem Description

给定一个无向连通图，顶点编号从0到n-1，用广度优先搜索(BFS)遍历，输出从某个顶点出发的遍历序列。(同一个结点的同层邻接点，节点编号小的优先遍历）

Input

输入第一行为整数n（0< n <100），表示数据的组数。
对于每组数据，第一行是三个整数k，m，t（0＜k＜100，0＜m＜(k-1)*k/2，0＜ t＜k），表示有m条边，k个顶点，t为遍历的起始顶点。 
下面的m行，每行是空格隔开的两个整数u，v，表示一条连接u，v顶点的无向边。

Output

输出有n行，对应n组输出，每行为用空格隔开的k个整数，对应一组数据，表示BFS的遍历结果。

Sample Input

1
6 7 0
0 3
0 4
1 4
1 5
2 3
2 4
3 5

Sample Output

0 3 4 2 5 1

Hint

用邻接表存储。

Source

邻接链表思路：

构建结果：

A[0] -> 4 -> 3

A[1] -> 5 -> 4

A[2] -> 5 -> 4 -> 3

A[3] -> 2 -> 0

A[4] -> 2 -> 1 ->0

A[5] -> 2

排序之后：

A[0] -> 3 -> 4

A[1] -> 4 -> 5

A[2] -> 3 -> 4 -> 5

A[3] -> 0 -> 2

A[4] -> 0 -> 1 ->2

A[5] -> 2

所以遍历  结果：（输入规定第一个节点编号 是 0了）

 0 3 4 5 2 1

代码一：

/*数据结构实验之图论一
*
*基于邻接链表的广度优先搜索遍历
*/
#include <bits/stdc++.h>
using namespace std;
struct node
{
    int data;
    node *next;
};
node *p, *a[1111];
int ans[111], cat[1111]; // cat为标记 ans为答案
int k, m, t, cnt;

void bfs(int i);

int main()
{
    int n, u, v;
    cin >> n;
    while (n--)
    {
        memset(cat, 0, sizeof(cat));
        cin >> k >> m >> t;
        for (int i = 0; i < k; i++) // k个节点  所以开辟k个点
        {
            a[i] = new node;
            a[i]->next = NULL;
        }
        for (int i = 0; i < m; i++)
        {
            cin >> u >> v;

            p = new node; // 无向图  建两次
            p->data = v;
            p->next = a[u]->next;
            a[u]->next = p;

            p = new node;
            p->data = u;
            p->next = a[v]->next;
            a[v]->next = p;
        }
        cnt = 0;

        bfs(t);

        for (int i = 0; i < cnt; i++)
        {
            if (i == cnt - 1)
                cout << ans[i] << endl;
            else
                cout << ans[i] << ' ';
        }
    }
    return 0;
}
void bfs(int i)
{
    for (int j = 0; j < k; j++)
    {
        for (node *t = a[j]->next; t; t = t->next)
        {
            for (node *q = t->next; q; q = q->next)
            {
                if (t->data > q->data)
                    swap(t->data, q->data);
            }
        }
    }
    queue<int> Q;
    Q.push(i);
    ans[cnt++] = i;
    cat[i] = 1;

    while (!Q.empty())
    {
        int num = Q.front();
        Q.pop();
        for (p = a[num]->next; p; p = p->next)
        {
            if (cat[p->data] == 0)
            {
                cat[p->data] = 1;
                Q.push(p->data);
                ans[cnt++] = p->data;
            }
        }
    }
}

代码二：  题目说用邻接链表做  但实际 邻接矩阵也能ac

/*数据结构实验之图论一
*
*基于邻接矩阵的广度优先搜索遍历
*
*/
#include <bits/stdc++.h>
using namespace std;
int gra[111][111];      // 邻接矩阵
int cat[111], ans[111]; //cat标记 // 存ans遍历结果
int k, m, t;            // k是定点个数 t 是起始顶点
int cnt;
void bfs(int i) // 通过队列实现bfs
{
    queue<int> q;
    ans[cnt++] = i; // 存入答案数组
    q.push(i);      // 入队
    cat[i] = 1;     // 遍历标记
    while (!q.empty())
    {
        int temp = q.front(); // 遍历temp的能到达的点
        q.pop();              // 出队
        for (int j = 0; j < k; j++)
        {
            if (cat[j] == 0 && gra[temp][j] == 1) //未曾遍历 且 此点和原队首有线连接
            {
                q.push(j);
                ans[cnt++] = j;
                cat[j] = 1;
            }
        }
    }
}
int main()
{
    int n, u, v;
    cin >> n;
    while (n--)
    {
        memset(gra, 0, sizeof(gra));
        memset(cat, 0, sizeof(cat));
        cin >> k >> m >> t;
        for (int i = 0; i < m; i++)
        {
            cin >> u >> v;
            gra[u][v] = gra[v][u] = 1;
        }
        cnt = 0;
        bfs(t); //传入起始点标号
        for (int i = 0; i < k; i++)
        {
            if (i == k - 1)
                cout << ans[i] << endl;
            else
                cout << ans[i] << ' ';
        }
    }
    return 0;
}


/***************************************************
User name: jk180602张国辉
Result: Accepted
Take time: 0ms
Take Memory: 252KB
Submit time: 2019-01-01 23:14:57
****************************************************/