4004.六度空间理论

六度空间理论

发布时间: 2018年11月26日 10:17   时间限制: 1000ms   内存限制: 128M

核心思想是使用BFS对邻接表扫描6层计数。

描述

“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。

输入

多组数据，每组数据m+1行。第一行有两个数字n和m，代表有n个人和m组朋友关系。n个人的编号为1到n。第二行到第m+1行每行包括两个数字a和b，代表这两个人互相认识。当n和m都等于0时，输入结束。

输出

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

样例输入1

10 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 8
1 2
2 3
3 4
4 5
5 6
6 7
7 8
9 10
0 0

样例输出1

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: 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%

#include<iostream>
#include<cstring>
using namespace std;
#define maxn 100

typedef struct node
{
    int data;
    struct node *next;
} Node;

Node *V[maxn];//邻接表
int visit[maxn];

void BFS(int s, int n)
{
    int count = 1;
    Node *p;
    memset(visit, 0, sizeof(visit));
    int Queue[maxn];
    int front = 0, rear = 0, last = 0;
    Queue[0] = s;
    visit[s] = 1;
    int six = 0;
    while (front <= last)
    {
        p = V[Queue[front++]]->next;
        while (p)//单层遍历，一个人的所有朋友遍历，Queue存储其友
        {
            if (!visit[p->data])
            {
                count++;//计数加一
                visit[p->data] = 1;//改变访问状态
                Queue[++rear] = p->data;//队尾赋值
            }
            p = p->next;
        }
        if (front>last)//判断此人的一度朋友是否遍历，如果遍历结束，进入其二度朋友
        {
            last = rear;
            six++;
            if (six == 6)
                break;
        }
    }
    printf("%d: %.2f%%
", s, count*100.0 / n);
}

int main()
{
    int n, m;
    int x, y;
    Node *p;
    while (1)
    {
        cin >> n >> m;
        if (!n&&!m)break;
        for (int i = 1; i <= n; i++)
        {
            V[i] =new Node;
            V[i]->data = i;
            V[i]->next = NULL;
        }//set up 邻接表 index
        while (m--)
        {
            cin>>x>>y;
            p = new Node;
            p->data = y;
            p->next = V[x]->next;
            V[x]->next = p;//y follow V[x]
            p = new Node;
            p->data = x;
            p->next = V[y]->next;
            V[y]->next = p;//x follow V[y]
        }
        for (int i = 1; i <= n; i++)
            BFS(i, n);
    }
    return 0;
}