05-图3. 六度空间 (30)

题目来源：http://www.patest.cn/contests/mooc-ds/05-%E5%9B%BE3

05-图3. 六度空间 (30)

时间限制

1500 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

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

图6.4 六度空间示意图

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

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

输入格式说明：

输入第1行给出两个正整数，分别表示社交网络图的结点数N （1<N<=10⁴，表示人数）、边数M（<=33*N，表示社交关系数）。随后的M行对应M条边，每行给出一对正整数，分别是该条边直接连通的两个结点的编号（节点从1到N编号）。

输出格式说明：

对每个结点输出与该结点距离不超过6的结点数占结点总数的百分比，精确到小数点后2位。每个结节点输出一行，格式为“结点编号:（空格）百分比%”。

样例输入与输出：

序号	输入	输出
1	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%
2	10 8 1 2 2 3 3 4 4 5 5 6 6 7 7 8 9 10	1: 70.00% 2: 80.00% 3: 80.00% 4: 80.00% 5: 80.00% 6: 80.00% 7: 80.00% 8: 70.00% 9: 20.00% 10: 20.00%
3	11 10 1 2 1 3 1 4 4 5 6 5 6 7 6 8 8 9 8 10 10 11	1: 100.00% 2: 90.91% 3: 90.91% 4: 100.00% 5: 100.00% 6: 100.00% 7: 100.00% 8: 100.00% 9: 100.00% 10: 100.00% 11: 81.82%
4	2 1 1 2	1: 100.00% 2: 100.00%

java 解：  有一个测试点没通过，原因还未找到

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;



class Node
{
	int value;
	ArrayList<Node> nextNodes = null;
	public Node(int i)
	{
		value= i;
		nextNodes = new ArrayList<Node>();
		
	}
}

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int m = scanner.nextInt();
		Node[] nodes = new Node[n+1];
		int[] visit = new int[n+1];
		Arrays.fill(visit, 0);
		for(int i=1;i<=n;++i)
		{
			Node node = new Node(i);
			nodes[i]=node;
		}
		for(int i=0;i<m;++i)
		{
			int start = scanner.nextInt();
			int end = scanner.nextInt();
			nodes[start].nextNodes.add(nodes[end]);
			nodes[end].nextNodes.add(nodes[start]);
		}
		DecimalFormat df = new DecimalFormat("#0.00");
		for(int i=1;i<=n;++i)
		{
	
			Arrays.fill(visit, 0);
			int num =0;
			//DFf
			searchDFS(i,nodes,visit,0);
			System.out.println(i+": "+df.format(  ((double)visit[0]/n)*100)+"%" );
			
			
		}
		
	}
	
	public static void searchDFS(int value, Node[] nodes,int[] visit , int level)
	{	
		if(visit[value]==1 || level==7)
			return ;
		else 
			visit[value]=1;
		visit[0]++;
		ArrayList<Node> nextNodes= nodes[value].nextNodes;
		
		for(Node node : nextNodes)
		{
			if(visit[node.value]==0)
			{
				searchDFS(node.value,nodes,visit,level+1);	
			}
		}
	
		
	}

}

参考别人的C++解：

#include <bits/stdc++.h>  
#define MAXN 10000+50  
using namespace std;  
bool vis[MAXN];  
bool connect[MAXN][MAXN];  
int n, m;  
int bfs(int x);  
int main()  
{  
    scanf("%d%d", &n, &m);  
    for(int i = 0; i < m; ++i){  
        int a, b;  
        scanf("%d%d", &a, &b);  
        connect[a-1][b-1] = true;  
        connect[b-1][a-1] = true;  
    }  
    for(int i = 0; i < n; ++i){  
        int ans = bfs(i);  
        printf("%d: %.2lf%%\n", i+1, ans*1.0/n*100);  
    }  
    return 0;  
}  
  
int bfs(int x){  
    memset(vis, false, sizeof(vis));  
    queue<pair<int,int> > q;  
    vis[x] = true;  
    q.push(make_pair(x, 0));  
    int cnt = 0;  
    while(!q.empty()){  
        pair<int,int> topElem = q.front();  
        q.pop();  
        if(topElem.second >= 7){  
            break;  
        }  
        cnt++;  
        for(int i = 0; i < n; ++i){  
            if(!vis[i] && connect[topElem.first][i]){  
                q.push(make_pair(i, topElem.second+1));  
                vis[i] = true;  
            }  
        }  
    }  
    return cnt;  
}