版权声明：本文为博主NJU_ChopinXBP原创文章，发表于CSDN，仅供交流学习使用，转载请私信或评论联系，未经博主允许不得转载。感谢您的评论与点赞。 https://blog.csdn.net/qq_20304723/article/details/83587035
2018.10.31
这道图题看起来很复杂，其实是一个简单的BFS。只要用邻接表记录所有边和结点（这里用HashMap嵌套链表实现），对每一个点进行一次六层的BFS（关于BFS可以看 #数据结构与算法学习笔记#PTA18：图（邻接表）+DFS（深度优先搜索）+BFS（广度优先搜索）（C/C++）），记录遍历的结点总个数即可。技巧在于需要设置标志位记录每次入队的最后一个结点，间接记录BFS的层数。因为java语言本身输入输出占用内存较大，这道题用java写总是跑不过最大的N和M，提示内存超限。因此另附一个C++版本可以跑通的代码，欢迎大家和我交流。
“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图1所示。
“六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学家努力追求的目标。然而由于历史的原因，这样的研究具有太大的局限性和困难。随着当代人的联络主要依赖于电话、短信、微信以及因特网上即时通信等工具，能够体现社交网络关系的一手数据已经逐渐使得“六度空间”理论的验证成为可能。
假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。
输入格式:
输入第1行给出两个正整数，分别表示社交网络图的结点数N（1<N≤104，表示人数）、边数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%Java实现：
/**
*
* @author ChopinXBP
* 六度空间
*
*/
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
public class SixDegreesofSeparation {
private static Scanner in = new Scanner(new BufferedInputStream(System.in));
private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
private static int pointNum;
private static int edgeNum;
private static int count = 0;
private static HashMap<Integer, ArrayList<Integer>> map = new HashMap<>();
public static void main(String[] args) {
// TODO Auto-generated method stub
// long start=System.currentTimeMillis(); //获取开始时间
Read();
in.close();
// long end=System.currentTimeMillis(); //获取结束时间
// System.out.println("程序运行时间： "+(end-start)+"ms");
double[] resultList = new double[pointNum + 1];
Solution(resultList);
Print(resultList);
out.close();
}
// 读取输入并存为图
private static void Read() {
pointNum = in.nextInt();
edgeNum = in.nextInt();
for (int i = 0; i < edgeNum; i++) {
int point1 = in.nextInt();
int point2 = in.nextInt();
if (!map.containsKey(point1)) {
ArrayList<Integer> p = new ArrayList<>();
p.add(point2);
map.put(point1, p);
} else {
map.get(point1).add(point2);
}
if (!map.containsKey(point2)) {
ArrayList<Integer> p = new ArrayList<>();
p.add(point1);
map.put(point2, p);
} else {
map.get(point2).add(point1);
}
}
}
// 每一个点进行一次6层BFS
private static void Solution(double[] resultList) {
int[] result = new int[pointNum + 1];
for (int i = 1; i <= pointNum; i++) {
Arrays.fill(result, 0);
count = 0;
BFS(i, result);
resultList[i] = (double) count / pointNum;
}
}
// 6层BFS
private static void BFS(int element, int[] result) {
result[element] = 1;
count = 1;
LinkedList<Integer> bfsQue = new LinkedList<>();
bfsQue.add(element);
int iterator = 6; // 记录遍历次数
int last = element;
int tail = 0;
while (!bfsQue.isEmpty() && iterator > 0) {
int p = bfsQue.pollFirst();
ArrayList<Integer> closepoint = map.get(p);
for (int i = 0; i < closepoint.size(); i++) {
int data = closepoint.get(i);
if (result[data] == 0) {
bfsQue.add(data);
result[data] = 1;
count++;
tail = data;
}
}
if (last == p) {
iterator--;
last = tail;
}
}
}
// 打印输出
private static void Print(double[] resultList) {
for (int i = 1; i <= pointNum; i++) {
out.print(i + ": ");
out.print(String.format("%.2f", resultList[i] * 100));
out.println("%");
}
}
}
C++实现示例：
#include <iostream>
#include <malloc.h>
#include <queue>
using namespace std;
bool* CreateMatrixGraph(const int& N)
{
int arraySize = N * (N + 1) / 2;
bool* graph = (bool*) malloc(sizeof(bool) * arraySize);
for (int i = 0; i < arraySize; i++)
{
graph[i] = 0;
}
return graph;
}
bool IsMatrixConnected(const int& a, const int& b, bool* graph, const int& N)
{
if (a == b)
{
return false;
}
if (a > b)
{
return (graph[a * (a + 1) / 2 + b]);
}
else
{
return (graph[b * (b + 1) / 2 + a]);
}
}
void MatrixConnect(const int& a, const int& b, bool* graph, const int& N)
{
if (a >= N || b >= N)
{
printf("ERROR : NODE OUT OF RANGE\n");
//return;
}
if (IsMatrixConnected(a, b, graph, N))
{
printf("ERROR : %d AND %d ALREADY CONNECTED\n", a, b);
//return;
}
if (a == b)
{
printf("ERROR : THE SAME VERTICE\n");
//return;
}
if (a > b)
{
graph[a * (a + 1) / 2 + b] = 1;
}
else
{
graph[b * (b + 1) / 2 + a] = 1;
}
}
void GetAdjoinVertice(const int& vertice, bool* graph, int* adjoinVertice, int N)
{
int currentIndex = 0;
// 横行计算
const int VERTICALPRIMEINDEX = (vertice*vertice + vertice) / 2;
for (int j = 0; j <= vertice; j++) // 共遍历了(vertice+1)个元素
{
if (graph[VERTICALPRIMEINDEX + j] == 1)
{
adjoinVertice[currentIndex++] = j;
}
}
// 竖向计算初始位置，该位置是横向计算的最后一个位置
const int COLUMNPRIMEINDEX = (vertice*vertice + vertice) / 2 + vertice;
for (int j = 0; j < N - vertice - 1; j++)
{
if (graph[COLUMNPRIMEINDEX + (j+1) * (vertice+1) + (j*j + j) / 2] == 1)
{
adjoinVertice[currentIndex++] = vertice + j + 1;
}
}
}
int BFS(bool* graph, int vertice, bool* isVisited, int N)
{
// 找vertice的朋友
queue<int> t;
t.push(vertice);
isVisited[vertice] = true;
// 近处的朋友包括自己我也是醉的不行
int closeFriendship = 1;
int lastLevelFriend = 0;
int currentLevel = 0;
int currentLevelFriend = 0;
while (!t.empty())
{
int currentVertice = t.front();
t.pop();
//printf("%d ", currentVertice);
int* adjoinVertice = (int*) malloc(sizeof(int) * N);
for (int i = 0; i < N; i++)
{
adjoinVertice[i] = -1;
}
GetAdjoinVertice(currentVertice, graph, adjoinVertice, N);
int i = 0;
// 如果上层朋友数已经为0，即当前层遍历已经结束，将当前层朋友数设为上层朋友数，然后当前层朋友数置0
if (lastLevelFriend == 0)
{
currentLevel++;
lastLevelFriend = currentLevelFriend;
currentLevelFriend = 0;
}
if (currentLevel > 6)
{
return closeFriendship;
}
// 遍历当前层的朋友
while (adjoinVertice[i] != -1)
{
if (!isVisited[adjoinVertice[i]])
{
t.push(adjoinVertice[i]);
isVisited[adjoinVertice[i]] = true;
closeFriendship++;
currentLevelFriend++;
}
i++;
}
if (lastLevelFriend > 0)
{
lastLevelFriend--;
}
free(adjoinVertice);
}
return closeFriendship;
}
int main()
{
int N;
int M;
scanf("%d %d", &N, &M);
N++;
bool* graph = CreateMatrixGraph(N);
for (int i = 0; i < M; i++)
{
int node1;
int node2;
scanf("%d %d", &node1, &node2);
MatrixConnect(node1, node2, graph, N);
}
bool* isVisited = (bool*) malloc(sizeof(bool) * N);
// 输出
for (int m = 1; m <= N - 1; m++)
{
for (int i = 0; i < N; i++)
{
isVisited[i] = false;
}
float closeFriend = BFS(graph, m, isVisited, N);
float percent = closeFriend / (N - 1) * 100;
printf("%d: %.2f%%\n", m, percent);
}
return 0;
}#Coding一小时，Copying一秒钟。留个言点个赞呗，谢谢你#