06-图3 六度空间（30 分）

“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图1所示。

图1 六度空间示意图

“六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学家努力追求的目标。然而由于历史的原因，这样的研究具有太大的局限性和困难。随着当代人的联络主要依赖于电话、短信、微信以及因特网上即时通信等工具，能够体现社交网络关系的一手数据已经逐渐使得“六度空间”理论的验证成为可能。

假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数N（1，表示人数）、边数M（≤，表示社交关系数）。随后的M行对应M条边，每行给出一对正整数，分别是该条边直接连通的两个结点的编号（节点从1到N编号）。

输出格式:

对每个结点输出与该结点距离不超过6的结点数占结点总数的百分比，精确到小数点后2位。每个结节点输出一行，格式为“结点编号:（空格）百分比%”。

输入样例:

10 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10

输出样例:

1: 70.00%
2: 80.00%
3: 90.00%
4: 100.00%
5: 100.00%
6: 100.00%
7: 100.00%
8: 90.00%
9: 80.00%
10: 70.00%

我的答案

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define MaxVertexMax 10000    /* 最大顶点数设为100 */
#define INFINITY     65535  /* 设为双字节无符号证书的最大值 */
#define MaxSize      330000

typedef int Vertex;
typedef int WeightType;
typedef char DataType;

typedef struct ENode *PtrToENode;
struct ENode {
    Vertex V1, V2;
    WeightType Weight;
};
typedef PtrToENode Edge;

typedef struct GNode *PtrToGNode;
struct GNode {
    int Nv;
    int Ne;
    WeightType G[MaxVertexMax][MaxVertexMax];
    DataType Data[MaxVertexMax];
};
typedef PtrToGNode MGraph;

struct QNode {
    Vertex Data[MaxSize];
    int rear;
    int front;
};
typedef struct QNode *Queue;

MGraph CreateGraph(int VertexNum)
{
    Vertex V, W;
    MGraph Graph;

    Graph = (MGraph)malloc(sizeof(struct GNode));
    Graph->Nv = VertexNum;
    Graph->Ne = 0;

    for(V=0;V<=Graph->Nv;V++)
        for(W=0;W<=Graph->Nv;W++)
            Graph->G[V][W] = INFINITY;

    return Graph;
}

void InsertEdge(MGraph Graph, Edge E)
{
    Graph->G[E->V1][E->V2] = E->Weight;
    Graph->G[E->V2][E->V1] = E->Weight;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;

    scanf("%d", &Nv);
    Graph = CreateGraph(Nv);
    scanf("%d
", &(Graph->Ne));
    if(Graph->Ne != 0) {
        E = (Edge)malloc(sizeof(struct ENode));
        E->Weight = 1;
        for(i=0;i<Graph->Ne;i++) {
            scanf("%d %d
", &E->V1, &E->V2);
            InsertEdge(Graph, E);
        }
    }

    for(V=0;V<Graph->Nv;V++)
        scanf(" %c", &(Graph->Data[V]));

    return Graph;
}

void PrintGraph(MGraph Graph)
{
    Vertex V, W;
    printf("Graph:
");
    for(V=1;V<=Graph->Nv;V++) {
        for(W=1;W<Graph->Nv;W++) 
            printf("%5d " ,Graph->G[V][W]);
        printf("
");
    }
    printf("-----------------------
");
}

//广度优先
int IsEmpty(Queue Q)
{
    return (Q->rear == Q->front);   //1:empty 0:not empty
}

void AddQ(Queue PtrQ, Vertex item)
{
    if((PtrQ->rear+1)%MaxSize == PtrQ->front) {
        printf("Queue full");
        return;
    }
    PtrQ->rear = (PtrQ->rear+1)%MaxSize;
    PtrQ->Data[PtrQ->rear] = item;
}

Vertex DeleteQ(Queue PtrQ)
{
    if(PtrQ->front == PtrQ->rear) {
        printf("Queue empty");
        return -1;
    } else {
        PtrQ->front = (PtrQ->front+1)%MaxSize;
        return PtrQ->Data[PtrQ->front];
    } 
}

void Visit(Vertex V)
{
    printf(" %d", V);
}

int IsEdge(MGraph Graph, Vertex V, Vertex W)
{
    return Graph->G[V][W]<INFINITY?1:0;
}

int BFS(MGraph Graph, Vertex S, int *Visited)
{
    Queue Q;
    Vertex V, W;
    int count = 0, level = 0, last = S, tail = 0;
    Q = (Queue)malloc(sizeof(struct QNode));

    // Visit(S);
    Visited[S] = 1;
    count++;
    AddQ(Q, S);

    while(!IsEmpty(Q)) {
        V = DeleteQ(Q);
        for(W=1;W<=Graph->Nv;W++) {
            if(!Visited[W] && IsEdge(Graph, V, W)) {
                // Visit(W);
                Visited[W] = 1;
                AddQ(Q, W);
                count++;
                tail = W;       //下一层最后一个
            }
        }
        if(V == last) {
            level++;
            last = tail;
        }
        if(level == 6) break;
    }

    return count;
}

int main()
{
    MGraph Graph;
    int *Visited, i, j;
    int count = 0;
    Graph = BuildGraph();
    Visited = (int *)malloc(sizeof(int)*(Graph->Nv+1));
    for(i=0;i<=Graph->Nv;i++)
        Visited[i] = 0;
    
    // PrintGraph(Graph);

    for(i=1;i<=Graph->Nv;i++) {
        if(!Visited[i]) {
            count = BFS(Graph, i, Visited);
            // printf(" count %d
", count);
            printf("%d: %2.2f%
", i, (float)count/Graph->Nv*100);
            for(j=0;j<=Graph->Nv;j++)
                Visited[j] = 0;
        }
    }
    return 0;
}