深入剖析-06-图3 六度空间 (30 分)

这道题是mooc上浙江大学陈越、何钦铭两位教授联合讲授的《数据结构》的一道课后练习题，是关于数据结构——图的应用练习。下面是题目内容：

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

**六度空间示意图**

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

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

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

陈越姥姥专门作为应用实例讲授了做这道题的方法，主要是讲了用广度优先搜索算法+层级控制方法。那么问题来了，程序=数据结构+算法，1.数据结构怎么选择？2.算法只能用广度优先搜索，不能用深度优先搜索吗？3.层级控制有没有更好的方法？下面我们来深入剖析这些问题。

一、数据结构选择问题

答案是：邻接表或邻接矩阵，各有优缺点。

图的数据结构表示可以用邻接矩阵、邻接表、边的结构数组等，姥姥视频里用的是伪码描述，没有明确用哪种方法表示这个图，实际上，题目限制了最大顶点数为1000，所以用邻接矩阵和邻接表表示图都是可以的。

如果用邻接矩阵表示图，int型1000X1000的二维数组，需要空间大概接近4Mb，距离题目限制的64Mb空间还有很大富余，优点是定义简单直观，代码少，缺点是顶点数再大一个数量级就会内存超限。

如果用邻接表表示图，因为是稀疏图，大概只需邻接矩阵所需空间的13%，更大的好处是，邻接表在搜索邻接点的时候效率高，缺点是数据结构较复杂、代码较多、实现起来稍显繁杂。

如果用边的结构数组表示图，那就要看是否超时的问题，我没有试过，暂时情况不明。

二、能用深度优先搜索吗？

答案是：不能。

无论用什么搜索方法，都要控制层级为6层，深度优先搜索可以比较方便的控制深度，但是，控制搜索深度，就违背了深度优先搜索算法的根本原理——走到底才能返回，所以深搜解决这个问题得到的答案是错误的。说到这，估计还是一头雾水，看一张图，就明白了。

从原点1出发，序号小的节点优先，先走1,2,4,6,8,10,9这条链并标记节点已访问，因控制深度为6层，所以程序返回，当再从1出发，继续走1,3,5,7.到节点9的时候，因节点9访问过，程序返回，此时会发现节点11相对于节点1在第5层，但并没有访问到。此例证明深搜解决六度空间问题是错误的。

三、有更好的层级控制方法吗？

答案是：有。

姥姥重点讲了用3个变量控制层级的方法。要理解这个方法，就要了解这个方法的实现基础。
层级控制的实现基础和方法：
1.广度优先搜索（层序遍历）的算法过程中所有节点都要入队，队列里的节点排列是规则的，也就是一层接着一层顺序入队，函数传入的节点为源节点，假定为0层，它在队列里位置最前，队列里紧接着的节点是源节点的邻接点，为第1层，第1层之后是第1层所有节点的邻接点，为第2层……
2.记住每一层最后一个节点。第0层只有一个节点，也就是源节点，所以很容易记住，第1层的最后一个节点是第0层的最后一个邻接点，也方便记住，以此类推。也可以这样理解，当第0层最后一个节点出队（注意：第0层只有一个节点），记住该节点的最后一个入队的邻接点，当这个记住的节点下次出队时，再记住该节点的最后一个入队的邻接点……
3.当某层的最后一个节点出队，层级加1。
以上就是实现层级控制的基础和方法。这个方法的缺点是稍显复杂，对照实现代码，理解起来略有难度。

其实有更简洁的方法，实现的基础是一样的，只用一个变量，定义为层级标识，用0和负数表示，以区别于图节点，层级标识节点跟图节点一样入队，插在层与层之间。过程是这样的（广搜+层级控制）：
1.层级标识0入队，紧接着第0层节点全部入队（第0层只有一个节点，即源节点）；
2.进入循环，循环条件是队列不空，且层级标识变量小于等于6；
3.队列里取一个元素；
4.取得的元素如果是层级标识节点（小于等于0），（层级标识节点出队）说明该层所有节点已经全部入队，下一层层级标识节点即可入队，进入下一轮循环；
5.否则是图节点，则做图节点系列处理。进入下一轮循环。
以上思路对照代码，并根据一个图的实例，按照程序推演，重点关注队列里的元素入队出队的情况，一看就明白，核心是理解第4点，基础是深入了解广搜（层序遍历）的节点入队出队过程。

欢迎交流。最后给出邻接表和邻接矩阵两种数据结构的程序代码。

四、邻接表+广搜+标识入队层级控制

#include <iostream>
#include <cstdlib>
#include <queue>
//#define WeightType int
#define Vertex short			//顶点最大1000，短整型即可，比整型省一半空间
//#define DataType int
#define MaxVertexNum 1001
#define SIX 6

using namespace std;
/*邻接表节点*/
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode{
	Vertex AdjV;
//	WeightType Weight;
	PtrToAdjVNode Next;
};
/*领接表头结点列表*/ 
typedef struct VNode{
	PtrToAdjVNode FirstEdge;
//	DataType Data;
}AdjList[MaxVertexNum];
/*图节点的头指针节点*/ 
typedef struct GNode *PtrToGNode;
struct GNode{
	int Nv, Ne;
	AdjList G;
};
typedef PtrToGNode LGraph;
/*边*/
typedef struct ENode *PtrToENode;
struct ENode{
	Vertex V1, V2;
//	WeightType Weight;
};
typedef PtrToENode Edge;
/*初始化图*/
LGraph CreateGraph(int VertexNum)
{
	Vertex V;
	LGraph Graph;
	
	Graph = (LGraph)malloc(sizeof(struct GNode));
	Graph->Nv = VertexNum;
	Graph->Ne = 0;
	
	for (V=1; V<=Graph->Nv; V++)
		Graph->G[V].FirstEdge = NULL;
		
	return Graph;
}
/*往图里插入边*/
void InsertEdge(LGraph Graph, Edge E)
{
	PtrToAdjVNode NewNode;
	
	NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
	NewNode->AdjV = E->V2;
//	NewNode->Weight = E->Weight;
	NewNode->Next = Graph->G[E->V1].FirstEdge;
	Graph->G[E->V1].FirstEdge = NewNode;

	NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
	NewNode->AdjV = E->V1;
//	NewNode->Weight = E->Weight;
	NewNode->Next = Graph->G[E->V2].FirstEdge;
	Graph->G[E->V2].FirstEdge = NewNode;	
}
/*建图并录入边*/
LGraph BuildGraph()
{
	LGraph Graph;
	Vertex Nv, V;
	Edge E;
	int i;
	
	scanf("%hd", &Nv);
	Graph = CreateGraph(Nv);
	scanf("%d", &(Graph->Ne));
	if ( Graph->Nv != 0){
		E = (Edge)malloc(sizeof(struct ENode));
		for (i=0; i<Graph->Ne; i++){
			scanf("\n%hd %hd", &E->V1, &E->V2);
			InsertEdge(Graph, E);
		}
		free(E);
	}
	
//	for (V=0; V<Graph->Ne; V++)
//		scanf("%d", &(Graph->G[V].Data));
	return Graph;
}
/*Six Degree of Separation广搜+标识节点入队层级控制算法*/
int SDS(LGraph Graph, Vertex V)
{
	queue <Vertex>QUEUE;			//定义一个队列（c++）
	int i, degree=0, cnt=0;			//degree层级标识，0和负数；cnt节点计数器 
	PtrToAdjVNode P;				//邻接表节点指针 
	bool visited[MaxVertexNum];		//访问记录表 
	for (i=0; i<=MaxVertexNum; i++)	//初始化访问记录表 
		visited[i] = false;	
	QUEUE.push(degree);				//层级标识0入队 
	QUEUE.push(V);					//源节点入队，也就是第0层节点入队，第0层只有1个节点 
	visited[V] = true;				//记录V节点为已访问 
	cnt++;							//访问节点数+1 
	while (!QUEUE.empty() && abs(degree) <= SIX){	//队列不空，且层级小于等于6进入循环 
		V = QUEUE.front(); QUEUE.pop();				//从队列中取一个元素 
		if (V <= 0){								//如果出队元素是层级标识节点 
			QUEUE.push(--degree);					//下一层层级标识节点入队，为负数 
			continue;								//进入下一轮循环 
		}
		P = Graph->G[V].FirstEdge;					//在邻接表里，节点V的第一个邻接点指针赋给P 
		while (P){									//当P不空 
			if (visited[P->AdjV] == false){			//如果P所指节点（V的邻接点）未被访问 
				QUEUE.push(P->AdjV);				//该邻接点入队 
				visited[P->AdjV] = true;			//标记该节点已访问 
				cnt++;								//访问节点数+1
			}
			P = P->Next;							//下一个邻接点 
		}
	}
	
	return cnt;						//返回访问节点总数 
}


int main()
{
	Vertex V;
	int n;
	LGraph Graph;
	Graph = BuildGraph();
	for (V=1; V<=Graph->Nv; V++){
		n = SDS(Graph, V);
		printf("%d: %.2f\%\n", V, (float)n*100/Graph->Nv);
	}	
	return 0;
}

五、邻接矩阵+广搜+标识入队层级控制

#include <iostream>
#include <cstdlib>
#include <queue>
#define Vertex short				//顶点最大1000，短整型即可，比整型省一半空间 
#define MaxVertexNum 1001
#define SIX 6
using namespace std;
short a[MaxVertexNum][MaxVertexNum];//邻接矩阵 
int N, M;							//N个节点，M条边定义为全局变量 
/*插入边 */
void InsertEdge(Vertex V1, Vertex V2)
{
	a[V1][V2] = true;
	a[V2][V1] = true;
}
/*初始化邻接矩阵图并录入边*/
void BuildGraph()
{
	Vertex V1, V2;
	int i, j;
	for (i=0; i<MaxVertexNum; i++)
		for (j=0; j<MaxVertexNum; j++)
			a[i][j] = false;
	scanf("%d", &N);
	scanf("%d", &M);
	if (N != 0)
		for (i=0; i<M; i++){
			scanf("\n%hd %hd", &V1, &V2);
			InsertEdge(V1, V2);
		}
}

/*广搜+标识入队层级控制算法*/
int SDS(Vertex V)
{
	queue <Vertex>QUEUE;			//定义一个队列（c++） 
	int i, degree=0, cnt=0;			//degree层级标识，0和负数；cnt节点计数器 
	bool visited[MaxVertexNum];		//访问记录表 
	for (i=0; i<=MaxVertexNum; i++)	//初始化访问记录表 
		visited[i] = false;	
	QUEUE.push(degree);				//层级标识0入队 
	QUEUE.push(V);					//源节点入队，也就是第0层节点入队，第0层只有1个节点 
	visited[V] = true;				//记录V节点为已访问 
	cnt++;							//访问节点数+1 
	while (!QUEUE.empty() && abs(degree) <= SIX){	//队列不空，且层级小于等于6进入循环 
		V = QUEUE.front(); QUEUE.pop();				//从队列中取一个元素 
		if (V <= 0){								//如果出队元素是层级标识节点 
			QUEUE.push(--degree);					//下一层层级标识节点入队，为负数 
			continue;								//进入下一轮循环 
		}
		for (i=1; i<=N; i++)						//处理图节点 
			if (a[V][i] == true && visited[i] == false){	//如果V的邻接点未被访问 
				QUEUE.push(i);						//V的邻接点i入队 
				visited[i] = true;					//标记V的邻接点i已访问 
				cnt++;								//访问节点数+1 
			}
	}	
	return cnt;						//返回已访问节点数 
}

int main()
{
	Vertex V;
	int n;
	BuildGraph();
	for (V=1; V<=N; V++){
		n = SDS(V);
		printf("%d: %.2f\%\n", V, (float)n*100/N);
	}	
	return 0;
}