06-图3 六度空间

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

图1 六度空间示意图

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

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

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数N（1<N≤10​4​​，表示人数）、边数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%

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10000

typedef struct QNode *Queue;
struct QNode{
	int front;
	int rear;
	int Maxsize;
	int *Q;
};
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode{
	int AdjV;
	PtrToAdjVNode Next;
};
typedef struct VNode{
	PtrToAdjVNode FirstEdge;
}AdjList[MaxSize]; 

typedef struct GNode *LGraph;
struct GNode{
	int Nv;
	int Ne;
	AdjList G;
};

LGraph BuiltG();
LGraph CreatG(int N,int M);
void InsertEdge(LGraph G,int V1,int V2);
int BFS(LGraph G,int V);
Queue CreatQ(int N);
void AddQ(Queue Q,int i);
int DeleteQ(Queue Q);
int IsEmpty(Queue Q);
void ReSet(int *P);
		
int	Visited[MaxSize]={};
		
int main()
{
	int V;
	int Num;
	LGraph G;
	G=BuiltG();
	for(V=0;V<G->Nv ;V++)
	{
		Num=BFS(G,V);	
		printf("%d: %.2f%%\n",V+1,(Num*1.0000/G->Nv)*100);
		ReSet(Visited); 
	}
	return 0;
}

void ReSet(int P[])
{
	int i;
	for(i=0;i<MaxSize;i++)
		P[i]=0; 
}

LGraph BuiltG()
{
	int N,M;
	int i;
	int V1,V2;
	scanf("%d %d",&N,&M);
	LGraph G;
	G=CreatG(N,M);
	for(i=0;i<G->Ne;i++)
	{
		scanf("%d %d",&V1,&V2);
		InsertEdge(G,V1-1,V2-1);
	}
	return G;
}

LGraph CreatG(int N,int M)
{
	int V;
	LGraph G=(LGraph)malloc(sizeof(struct GNode));
	G->Nv=N;
	G->Ne=M;
	for(V=0;V<G->Nv;V++)
		G->G[V].FirstEdge=NULL;
	return G;
}

void InsertEdge(LGraph G,int V1,int V2)
{
	PtrToAdjVNode NewNode;
	NewNode=(PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
	NewNode->AdjV=V2;
	NewNode->Next=G->G[V1].FirstEdge;
	G->G[V1].FirstEdge=NewNode;
	
	NewNode=(PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
	NewNode->AdjV=V1;
	NewNode->Next=G->G[V2].FirstEdge;
	G->G[V2].FirstEdge=NewNode;
}

int BFS(LGraph G,int V)
{
	int Num=1;
	Queue Q;
	int level=0,last=V,tail=last;
	Q=CreatQ(G->Nv);
	Visited[V]=1;
	AddQ(Q,V);
	while(!IsEmpty(Q))
	{
		V=DeleteQ(Q);
		PtrToAdjVNode W;
		for(W=G->G[V].FirstEdge;W;W=W->Next)
		{
			if(!Visited[W->AdjV])
			{
				Visited[W->AdjV]=1;
				AddQ(Q,W->AdjV);
				Num++;
				tail=W->AdjV;//tail最终更新为出队节点连通的最后一个节点
			}	
		}
		if(V==last)//V是出队节点 last代表该层的末尾节点 ，每次出队一个节点判断一次 ，若相等那么层数增加
			/*
			第一层：第一次出队一个节点，所以tail指向下一层的末尾节点，层数更新，last指向下一层最末尾节点；（第一层last需要初始化为第一个入队节点） 
			第 k层：last指向该层最末尾节点，tail每出队一个节点更新一次，等到出队节点V==last，此时tail更新至下一层末尾节点 ,level更新至本层； 
			*/ 
		{
			level++;//把最早的一层理解为level=0,level是等该层节点全部出队后更新至下一层，last指向level层末尾节点，
					//此时level层节点全部入队还未出队，因此Num每入队一次++，不能每出队一次++； 
			last=tail;
		}
		if(level==6)
			break;
	}
	return Num;
}

Queue CreatQ(int N)
{
	Queue Q=(Queue)malloc(sizeof(struct QNode));
	Q->Q=(int *)malloc((N+1)*sizeof(int));
	Q->front=Q->rear=-1;
	Q->Maxsize=N;
	return Q;
}

void AddQ(Queue Q,int i)
{
	Q->Q[(++Q->rear)%(Q->Maxsize)]=i;
}

int DeleteQ(Queue Q)
{
	return (Q->Q[(++Q->front)%(Q->Maxsize )]);
}

int IsEmpty(Queue Q)
{
	return Q->front == Q->rear;
}