MOOC 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，其中的难点是如何只遍历到第6层；老师给的方法非常巧妙，聪明的小套路，两个变量Last和Tail，Last是每一层的最后一个，Tail是最近入队列的一个，当出队列的值==Last时，说明这一层遍历完成了，Last  = Tail;

        整体难度不大，勤加练习，每天进不一点点，诸君共勉；

小知识点：C语言中 % 是个特殊的字符，想要打印出来需要 用"%%"

printf("%%");

完整代码（个人习惯指针带 * ，所以没有像老师那样将指针定义为图）

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

typedef int Vertex; //顶点

typedef struct _Edge{ //边
	Vertex V1,V2;
}Edge;

typedef struct _AdjV AdjV; //邻接点
struct _AdjV{
	Vertex V;
	AdjV* Next;
};

typedef struct _LGraph{ //邻接表表示的图
	int Nv;
	int Ne;
	AdjV** G;  //邻接表；G是一个指针数组，大小根据Nv来确定，数组每个元素是一个指针AdjV*
}LGraph;

typedef struct _Queue{ //队列
	Vertex* QueArray;
	int front;
	int rear;
}Queue;

LGraph* BuildGraph( );

void InsertEdge( LGraph* Graph,Edge E );

void SixDegrees( LGraph* Graph );

int BFS( LGraph* Graph,Vertex V );

Queue* CreateQ( int Nv );

void AddQ( Queue* Q,Vertex V );

Vertex DeleteQ( Queue* Q );

bool IsEmpty( Queue* Q );

void InitilizeVisited( bool Visited[],int Nv );

int NumTrueOfVisited( bool Visited[],int Nv );

void FreeGraph( LGraph* Graph );

int main()
{
	LGraph* Graph = BuildGraph( );
	
	SixDegrees( Graph );
	
	FreeGraph( Graph );
	
	return 0;
}

//根据输入的数据建图
LGraph* BuildGraph( )
{
	int N,M;
	scanf("%d %d",&N,&M);
	
	LGraph* Graph = (LGraph*)malloc(sizeof(LGraph));
	
	Graph->Nv = N+1; //题目是顶点从1开始，所以+1，G[0]浪费
	Graph->Ne = M;
	
	Graph->G = malloc((Graph->Nv)*sizeof(AdjV*));
	
	Vertex V;
	for(V=0;V<Graph->Nv;V++){
		
		Graph->G[V] = NULL;
	}
	
	Edge E;
	int i;
	for(i=0;i<Graph->Ne;i++){
		
		scanf("%d %d",&E.V1,&E.V2);
		
		InsertEdge( Graph,E );
	}
	
	return Graph;
}

//插入边函数
void InsertEdge( LGraph* Graph,Edge E )
{
	AdjV* NewNode;
	
	NewNode = (AdjV*)malloc(sizeof(AdjV));
	NewNode->V = E.V2;
	NewNode->Next = Graph->G[E.V1];
	Graph->G[E.V1] = NewNode;
	
	NewNode = (AdjV*)malloc(sizeof(AdjV));
	NewNode->V = E.V1;
	NewNode->Next = Graph->G[E.V2];
	Graph->G[E.V2] = NewNode;
}

//验证六度空间理论的算法
void SixDegrees( LGraph* Graph )
{
	int NumsConformToSixDegrees;
	double Proportion;
	Vertex V;
	for(V=1;V<Graph->Nv;V++){
		
		NumsConformToSixDegrees = BFS( Graph,V );
		
		Proportion =(1.0*NumsConformToSixDegrees/(Graph->Nv-1))*100;
		
		printf("%d: %.2lf%%\n",V,Proportion);
	}	
}

//核心BFS
int BFS( LGraph* Graph,Vertex V )
{
	bool Visited[Graph->Nv];
	InitilizeVisited( Visited,Graph->Nv );
	
	Queue* Q = CreateQ( Graph->Nv );
	
	Visited[V] = true;
	
	AddQ( Q,V );
	
	Vertex W,Tail,Last = V;
	int Level=0;
	AdjV* p;
	while( !IsEmpty( Q )){
		
		W = DeleteQ( Q );
		
		for(p=Graph->G[W];p;p=p->Next){
			
			if(!Visited[p->V]){
				
				Visited[p->V] = true;
				
				AddQ( Q,p->V );
				
				Tail = p->V;
			}
		}
		
		if(Last == W){
			Level++;
			Last = Tail;
		}
		
		if(Level==6){
			break;
		}
	}
	
	free(Q);
	
	int NumsConformToSixDegrees = NumTrueOfVisited( Visited,Graph->Nv );
	
	return NumsConformToSixDegrees;
}

//队列及其相关操作
Queue* CreateQ( int Nv )
{
	Queue* Q = (Queue*)malloc(sizeof(Queue));
	
	Q->QueArray = malloc(Nv*sizeof(Vertex));
	
	Q->front = Q->rear = -1;
	
	return Q;
}

void AddQ( Queue* Q,Vertex V )
{
	Q->rear++;
	
	Q->QueArray[Q->rear] = V;
}

Vertex DeleteQ( Queue* Q )
{
	Q->front++;

	return Q->QueArray[Q->front];
}

bool IsEmpty( Queue* Q )
{
	return Q->front == Q->rear ? true : false;	
}

/*其他辅助函数*/
//初始化访问数组
void InitilizeVisited( bool Visited[],int Nv )
{
	Vertex V;
	for(V=0;V<Nv;V++){
		
		Visited[V] = false;
	}
}

//算出已访问的人数
int NumTrueOfVisited( bool Visited[],int Nv )
{
	int Sum = 0 ;
	
	Vertex V;
	for(V=1;V<Nv;V++){
		
		if(Visited[V]){
			
			Sum++;
		}
	}
	
	return Sum;
}

//有malloc 就有free
void FreeGraph( LGraph* Graph )
{
	AdjV *p,*q;
	Vertex V;
	for(V=0;V<Graph->Nv;V++){
		
		for(p=Graph->G[V];p;p=q){
			
			q=p->Next;
			free(p);
		}
	}
	
	free(Graph->G);
	free(Graph);
}