六度空间

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

解法：使用图的BFS算法，使用邻接表存储图，同时每个节点存储图节点的深度信息，对>6的节点不搜索。

def BFS(L,k):
	import copy
	l=copy.deepcopy(L)
	count=0
	buf=[]
	buf.append(k)
	visited=[0 for i in range(len(L))]
	while buf!=[]:
		t=buf[0]
		visited[t]=1
		count+=1
		del buf[0]
		for i in l[t][1:]:
			if i not in buf and visited[i]==0:
				l[i][0]=l[t][0]+1
				if l[i][0]<=6:
					buf.append(i)
	return count

N,M=list(map(int,input().split()))
#列表0号元素为层次
L=[[0] for i in range(N)]
#将1~N映射为0~N-1 用邻接表存储 给每个节点设置权重
for k in range(M):
	i,j=list(map(int,input().split()))
	L[i-1].append(j-1)
	L[j-1].append(i-1)

#print(L)
for k in range(N):
	print(str(k+1)+': %.2f%%'%(BFS(L,k)/N*100))

但这样内存耗费比较多，PTA最后一组测试没通过。

改进法：认为每个节点入队即代表被访问，这样就不需要if i not in buf这个判断（这个判断额外增加O(n)时间复杂度）；不给每个节点添加层次信息，通过tail跟踪当前节点，last指向上一层节点，level表示当前层次数目。

#还要改进，这里的buf不应该用来判断是否在里面
def BFS(L,k):
	import copy
	l=copy.deepcopy(L)
	buf=[]
	buf.append(k)
	count=1
	visited=[0 for i in range(len(L))]
	visited[k]=1
	tail=k#指向跟踪当前层次节点
	last=k#指向上一层次最后一个节点
	level=0
	while buf!=[]:
		if level==6:
			return count
		for i in l[buf[0]]:
			if visited[i]==0:
				buf.append(i)
				count+=1
				visited[i]=1#只要入队就认为访问了
				tail=i	
		if buf[0]==last:
			level+=1
			last=tail
		del buf[0]		
	return count

N,M=list(map(int,input().split()))
L=[[] for i in range(N)]
#将1~N映射为0~N-1 用邻接表存储
for k in range(M):
	i,j=list(map(int,input().split()))
	L[i-1].append(j-1)
	L[j-1].append(i-1)

#print(L)
for k in range(N):
	print(str(k+1)+': %.2f%%'%(BFS(L,k)/N*100))

但是最后一个测试仍然没通过，感觉是l=copy.deepcopy(L)时间复杂度为O(n^​2)，
因为L有两层，deepcopy就会复制两层，导致整个搜索效率为O(n^3)。

仔细观察，发现前面之所以要加copy是因为第一种给节点加层次序号的方法，在BFS中会修改图，所以需要copy，而第二种方法并没有改变图，所以不需要copy，直接使用L即可，最终成功运行。

由此分析，第一次没成功的原因不仅仅与空间复杂度有关，还与python的copy所带来的时间复杂度有关（层次越深，复杂度是幂函数数量级增加）

def BFS(L,k):
	buf=[]
	buf.append(k)
	count=1
	visited=[0 for i in range(len(L))]
	visited[k]=1
	tail=k#指向跟踪当前层次节点
	last=k#指向上一层次最后一个节点
	level=0
	while buf!=[]:
		if level==6:
			return count
		for i in L[buf[0]]:
			if visited[i]==0:
				buf.append(i)
				count+=1
				visited[i]=1#只要入队就认为访问了
				tail=i	
		if buf[0]==last:
			level+=1
			last=tail
		del buf[0]		
	return count

N,M=list(map(int,input().split()))
L=[[] for i in range(N)]
#将1~N映射为0~N-1 用邻接表存储
for k in range(M):
	i,j=list(map(int,input().split()))
	L[i-1].append(j-1)
	L[j-1].append(i-1)

#print(L)
for k in range(N):
	print(str(k+1)+': %.2f%%'%(BFS(L,k)/N*100))