浙大数据结构第六周之06-图3 六度空间

题目详情：

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

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

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

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数N（1<N≤103，表示人数）、边数M（≤33×N，表示社交关系数）。随后的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%

主要思路：

利用BFS搜索，难点在于如何判断最后一个节点从而积累层数，解决方法是要先深刻理解BFS就是拓展层序遍历，弹出的是中心节点，加入的是围绕其的节点，所以分别记录当前层最后一个节点与上一层最后一个节点，当现在的中心节点等于上一层的最后一个节点就说明一层遍历完了

第一次写错误：

（1）忽视了节点是从1开始编号的

（2）人计数时从1开始，因为当前节点也在内

（3）一开始用DFS，但有问题，具体原因可以参见这篇文章

代码实现：

/*
建图
BFS，距离<=6的节点都要count，count保存在以此为起点的节点中
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX_NODE_NUMS 1005
#define TRUE 1
#define FALSE 0 
#define NONE -1
typedef int bool;
/*建立图*/
typedef struct MatrixGraphNode MatrixGraphNode;
typedef MatrixGraphNode* MatrixGraph;
struct MatrixGraphNode {
    int VertexNums, EdgeNums;
    int Weight[MAX_NODE_NUMS][MAX_NODE_NUMS];
};
MatrixGraph CreateEmptyGraph(int nodeNums) {
    MatrixGraph graph = (MatrixGraph)malloc(sizeof(MatrixGraphNode));
    graph->VertexNums = nodeNums;
    for(int i = 0; i <= nodeNums; i++) { //节点的编号是从1开始的
        for(int j = 0; j <= nodeNums; j++) {
            graph->Weight[i][j] = FALSE;
        }
    }  
    return graph;
}
void InsertEdge(int start, int end, MatrixGraph graph) {
    graph->Weight[start][end] = TRUE;
    graph->Weight[end][start] = TRUE;
    return; 
}
MatrixGraph BuildGraph(int nodeNums, int edgeNums) {
    MatrixGraph graph = CreateEmptyGraph(nodeNums);
    for(int i = 1; i <= edgeNums; i++) {
        int start, end;
        scanf("%d %d", &start, &end);
        InsertEdge(start, end, graph);
    }
    return graph;
}
/*实现队列的数据结构*/
typedef struct QueueNode QueueNode;
typedef QueueNode* Queue;
struct QueueNode {
    int Head, Rear, Size;
    int Data[MAX_NODE_NUMS];
};
void Init(Queue* q) {
    (*q)->Head = 0;
    (*q)->Rear = -1;
    (*q)->Size = 0;
    for(int i = 0; i < MAX_NODE_NUMS; i++) {
        (*q)->Data[i] = NONE;
    }
    return;
}
bool IsFull(Queue* q) {
    if((*q)->Size == MAX_NODE_NUMS) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}
bool IsEmpty(Queue* q) {
    if((*q)->Size == 0) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}
int Dequeue(Queue* q) {
    if(IsEmpty(q)) {
        return NONE;
    }
    int ret = (*q)->Data[(*q)->Head];
    (*q)->Head = ((*q)->Head + 1) % MAX_NODE_NUMS;
    (*q)->Size--;
    if((*q)->Head >= 1) (*q)->Data[(*q)->Head - 1] = NONE;
    return ret;
}
void Enqueue(Queue* q, int data) {
    if(!IsFull(q)) {
        (*q)->Rear = ((*q)->Rear + 1) % MAX_NODE_NUMS;
        (*q)->Data[(*q)->Rear] = data;
        (*q)->Size++;
        return;
    }
}
/*BFS*/
int Visited[MAX_NODE_NUMS];
void Clear(int size) {
    for(int i = 1; i <= size; i++) Visited[i] = 0;
    return;
}
int peopleInside = 1;
void BFS(MatrixGraph graph, int center) {   //用center命名更符合BFS搜索本质，一个节点为中心将其临近节点全部压入
    Queue myQueue = (Queue)malloc(sizeof(QueueNode));
    Init(&myQueue);
    Visited[center] = 1;
    Enqueue(&myQueue, center);
    int thisLevelTail = -1;
    int level = 0;
    int lastTail = center;
    while(!IsEmpty(&myQueue)) {
        center = Dequeue(&myQueue);
        for(int i = 1; i <= (graph -> VertexNums); i++) {
            if(Visited[i] == 0 && graph->Weight[center][i] == TRUE) {
                Enqueue(&myQueue, i);
                thisLevelTail = i;   //thisleveltail记录的是这一层的最后一个
                Visited[i] = 1;
                peopleInside++;
            }
        }
        if(center == lastTail) {    //如果这一层中心点到了上一层末尾，说明队列里之后存放就是下一层节点了
            level++;
            lastTail = thisLevelTail;
        }
        if(level == 6) break;
    }
}
int main() {
    int nodeNums, edgeNums;
    scanf("%d %d", &nodeNums, &edgeNums);
    MatrixGraph graph = BuildGraph(nodeNums, edgeNums);
    for(int i = 1; i <= nodeNums; i++) {
        Clear(nodeNums);
        BFS(graph, i);
        printf("%d: %.2f%%\n", i, 1.0 * peopleInside / (nodeNums) * 100);
        peopleInside = 1;
    }
    free(graph);
    return 0;
}