【图】列出连通集

【图】列出连通集

题目传送门

题目要求：

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式：

输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式：

按照"{ v₁v₂… v_k}"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例：

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

输出样例：

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

解题思路：

用邻接矩阵实现，建空图，插入边，DFS,BFS操作。

注意：

DFS和BFS之间要进行重置操作，需要将所有顶点置为未被访问过，否则会对下次的遍历造成影响。

完整程序：

/*【解题思路】用邻接矩阵实现，建空图，插入边，DFS,BFS操作*/
/*【注意】DFS和BFS之间要进行重置操作，需要将所有顶点置为未被访问过，否则会对下次的遍历造成影响*/
#include <stdio.h>
#include <stdlib.h>
#define MaxVertexNum 10
typedef int ElementType;

/*图结构的定义*/
typedef struct GNode *PtrToGNode;
struct GNode {
    int Nv; // 顶点数
    int Ne; // 边数
    int G[MaxVertexNum][MaxVertexNum]; // 邻接矩阵
    int visited[MaxVertexNum]; // 定义顶点有没有被访问过
};
typedef PtrToGNode MGraph; // 以邻接矩阵存储的图类型

/*边结构的定义*/
typedef struct ENode *PtrToENode;
struct ENode {
    int v1,v2; // 边两端的顶点
};
typedef PtrToENode Edge; // 用两个整型来表示一条有向边

/*队列结构定义*/
typedef struct QNode *Queue;
struct QNode {
    int Data[MaxVertexNum + 1]; // 因为循环队列会浪费一个空间，所以多申请一个
    int Front,Rear;
};
typedef Queue Q; // 实现一个循环队列

MGraph CreateGraph(int vertexNum,int edgeNum); // 创建空图
void InsertEdge(MGraph graph,Edge e); // 插边
MGraph BuildGraph(); // 建立图
void DFS(MGraph graph,int v); // DFS
void ListDFS(MGraph graph); // ListDFS
Queue CreateQueue(); // 创建空队列
int IsEmpty(Queue Q); // 队列判空
int IsFull(Queue Q); // 队列判满
void AddQ(Queue Q,ElementType e); // 入队
ElementType DeleteQ(Queue Q); // 出队
void BFS(MGraph graph,int v); // BFS
void ListBFS(MGraph graph,int v); // ListBFS
void Reset(MGraph graph); // 重置

// 创建空图（只有指定个顶点，而没有边的图）
MGraph CreateGraph(int vertexNum,int edgeNum)
{
    MGraph graph;
    int i,j;
    graph = (MGraph)malloc(sizeof(struct GNode));
    graph -> Nv = vertexNum;
    graph -> Ne = edgeNum;
    for(i = 0;i < graph -> Nv;i ++)
        for(j = 0;j < graph -> Nv;j ++)
            graph -> G[i][j] = 0; // 题目是无权图，所以只需要置0即可，0表示无边。但是有权图就需要重新考虑了
    for(i = 0;i < graph -> Nv;i ++)
        graph -> visited[i] = 0; // 全没有被访问过
    return graph;
}

// 给另个顶点之间插入一条边
void InsertEdge(MGraph graph,Edge e)
{
    graph -> G[e -> v1][e -> v2] = 1; // 无权图，用1表示有边，v1到v2有一条边
    graph -> G[e -> v2][e -> v1] = 1;// 无向图，v2到v1也有一条边
}

// 建立图
MGraph BuildGraph()
{
    MGraph graph;
    Edge e;
    int N,E; // 顶点树和边数
    int i;
    scanf("%d %d",&N,&E);
    graph = CreateGraph(N,E);
    if(E != 0) { // 边数不为0，需要插入边
        e = (Edge)malloc(sizeof(struct ENode));
        for(i = 0;i < E;i ++) {
            scanf("%d %d",&e -> v1,&e -> v2);
            InsertEdge(graph,e);
        }
    }
    return graph;
}

// DFS
void DFS(MGraph graph,int v) // v：顶点序号
{
    graph -> visited[v] = 1;
    printf("%d ",v);
    int i;
    for(i = 0;i < graph -> Nv;i ++) { // 如果v的邻接顶点没有被访问过
        if(graph -> visited[i] == 0 && graph -> G[v][i] == 1)
            DFS(graph,i);
    }
}

// ListDFS(可以对非连通图进行DFS)
void ListDFS(MGraph graph)
{
    int i;
    for(i = 0;i < graph -> Nv;i ++) {
        if(graph -> visited[i] == 0) {
            printf("{ ");
            DFS(graph,i);
            printf("}\n");
        }
    }
}

// 创建空队列
Queue CreateQueue()
{
    Queue Q;
    Q = (Queue)malloc(sizeof(struct QNode));
    Q -> Front = Q -> Rear = 0;
    return Q;
}

// 判空
int IsEmpty(Queue Q)
{
    if(Q -> Front == Q -> Rear)
        return 1;
    else
        return 0;
}

// 判满
int IsFull(Queue Q)
{
    if(Q -> Front == (Q -> Rear + 1) % MaxVertexNum)
        return 1;
    else
        return 0;
}

// 入队
void AddQ(Queue Q,ElementType e)
{
    if(IsFull(Q))
        return;
    else{
        Q -> Data[Q -> Rear] = e;
        Q -> Rear = (Q -> Rear + 1) % MaxVertexNum;
    }   
}

// 出队
ElementType DeleteQ(Queue Q)
{
    ElementType qe; // 记录要出队的元素
    if(IsEmpty(Q))
        return -1;
    else {
        qe = Q -> Data[Q -> Front];
        Q -> Front = (Q -> Front + 1) % MaxVertexNum;
        return qe;
    }
}

// BFS
void BFS(MGraph graph,int v) // v：顶点序号
{
    int i; 
    ElementType tmp;// tmp记录出队元素
    Queue Q;
    Q = CreateQueue();
    AddQ(Q,v);
    graph -> visited[v] = 1; // 只要入队就标记为已访问
    while(!IsEmpty(Q)) {
        tmp = DeleteQ(Q);
        printf("%d ",tmp);
        for(i = 0;i < graph -> Nv;i ++) { // tmp的邻接顶点没有被访问过
            if(graph -> visited[i] == 0 && graph -> G[tmp][i] == 1) {
                AddQ(Q,i);
                graph -> visited[i] = 1;
            }
        }
    }
}
// ListBFS
void ListBFS(MGraph graph)
{
    int i;
    for(i = 0;i < graph -> Nv;i ++) {
        if(graph -> visited[i] == 0) {
            printf("{ ");
            BFS(graph,i);
            printf("}\n");
        }
    }
}

// 重置
void Reset(MGraph graph)
{
    int i;
    for(i = 0;i < graph -> Nv;i ++)
        graph -> visited[i] = 0; // 全部重置为未被访问过
}

int main()
{
    MGraph graph;
    graph = BuildGraph();
    ListDFS(graph);
    Reset(graph);
    ListBFS(graph);
    return 0;
}