六度空间

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

图1 六度空间示意图

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

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

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数

输出格式:

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

输入样例:

输出样例:

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%

解题思路

　　一开始以为这道题目很难，但想了一下找到了解题思路，发现其实还蛮简单的。当时第一反应是用DFS，不过最后一个测试点没过。后面在网上发现这道题不能够用DFS，因为我们不是把整一个图都遍历一遍，而是只遍历指定深度的点，这会导致一些在指定深度范围内的点范围不到，遍历就结束了。下面来举个例子：

　　但按照六度空间理论，这个例子中，按照路线1->3->5->6->7->8->9，顶点9也是可以访问的。从这个例子可以看到DFS在本题中并不适用。如果要用DFS，就必须进行相应的修改。

　　所以后面我改用了BFS。和原本的BFS一样，只不过我们需要添加一个遍历深度不超过6的条件。不过有一个难点就是，怎么知道每层的最后一个点是哪个？因为我们只有找到每层的最后那个点，深度才可以+1。

　　当时我是这样想的，设一个标识符“-1”，代表着如果从队列中弹出“-1”就表明该层的顶点都已经访问过了，深度需要+1，同时再把“-1”压入队列。

　　相应的代码如下：

 1 int BFS(LGraph *graph, int src) {
 2     bool vis[graph->verN] = {false};
 3     int depth = 0, cnt = 1; // 变量depth用来记录遍历的深度，cnt用来记录从始点src开始一共可以遍历得到的点的个数 
 4     std::queue<int> q;
 5     q.push(src);
 6     vis[src] = true;
 7     q.push(-1);             // 在把src压入队列后，再压入"-1"，代表src是第0层的最后一个点 
 8     
 9     while (!q.empty() && depth < 6) {   // 循环条件为队列不为空并且深度不超过6 
10         int v = q.front();
11         q.pop();
12         if (v == -1) {      // 如果弹出的是"-1" 
13             depth++;        // 深度+1 
14             q.push(-1);     // 同时再把"-1"压入队列，在队列中"-1"的前一个元素就是深度+1后那一层的最后一个点 
15             continue; 
16         }
17         
18         for (AdjVNode *w = graph->G[v]; w; w = w->next) {
19             if (!vis[w->adjVer]) {
20                 q.push(w->adjVer);
21                 vis[w->adjVer] = true;
22                 cnt++;      // 每访问一个新的点，cnt就要+1 
23             }
24         }
25     }
26     
27     return cnt;
28 }

　　姥姥还给了另外一种思路，就是用一个变量来记录每层最后的那个点。每次在把从队列中弹出的点的邻接的点压入队列后，判断从队列中弹出的点是否与记录的那个点相同，如果相同就深度+1，同时在把那个变量更新记录当前队列的最后一个元素，而这个元素就是该层的最后那个点。

　　相应的代码如下：

 1 int BFS(LGraph *graph, int src) {
 2     bool vis[graph->verN] = {false};
 3     int depth = 0, last = src, cnt = 1; // last用来记录某层的最后一个点，一开始第0层的最后一个点就是src 
 4     std::queue<int> q;
 5     q.push(src);
 6     vis[src] = true;
 7     
 8     while (!q.empty() && depth < 6) {   // 循环条件为队列不为空并且深度不超过6
 9         int v = q.front();
10         q.pop();
11         for (AdjVNode *w = graph->G[v]; w; w = w->next) {
12             if (!vis[w->adjVer]) {
13                 q.push(w->adjVer);
14                 vis[w->adjVer] = true;
15                 cnt++;
16             }
17         }
18         if (v == last) {        // 当发现某个点与last记录的点相同，说明该层的点都已经变量过了 
19             depth++;            // 深度+1 
20             last = q.back();    // 更新last，为队列的最后一个元素，这个元素是该层的最后那个点 
21         }
22     }
23     
24     return cnt;
25 }

　　两种版本的AC代码如下：

 1 #include <cstdio>
 2 #include <queue>
 3 
 4 struct AdjVNode {
 5     int adjVer;
 6     AdjVNode *next;
 7 };
 8 
 9 struct LGraph {
10     AdjVNode **G;
11     int verN, edgeN;
12 };
13 
14 LGraph *createLGraph(int n, int m);
15 int BFS(LGraph *graph, int src);
16 
17 int main() {
18     int n, m;
19     scanf("%d %d", &n, &m);
20     LGraph *graph = createLGraph(n, m);
21     
22     for (int v = 0; v < graph->verN; v++) {
23         int cnt = BFS(graph, v);
24         printf("%d: %.2f%%\n", v + 1, 100.0 * cnt / graph->verN);
25     }
26     
27     return 0;
28 }
29 
30 LGraph *createLGraph(int n, int m) {
31     LGraph *graph = new LGraph;
32     graph->verN = n;
33     graph->edgeN = m;
34     graph->G = new AdjVNode*[graph->verN];
35     for (int v = 0; v < graph->verN; v++) {
36         graph->G[v] = NULL;
37     }
38     
39     for (int i = 0; i < graph->edgeN; i++) {
40         int v, w;
41         scanf("%d %d", &v, &w);
42         AdjVNode *tmp = new AdjVNode;
43         tmp->adjVer = w - 1;
44         tmp->next = graph->G[v - 1];
45         graph->G[v - 1] = tmp;
46         
47         tmp = new AdjVNode;
48         tmp->adjVer = v - 1;
49         tmp->next = graph->G[w - 1];
50         graph->G[w - 1] = tmp;
51     }
52     
53     return graph;
54 }
55 
56 int BFS(LGraph *graph, int src) {
57     bool vis[graph->verN] = {false};
58     int depth = 0, last = src, cnt = 1;
59     std::queue<int> q;
60     q.push(src);
61     vis[src] = true;
62     
63     while (!q.empty() && depth < 6) {
64         int v = q.front();
65         q.pop();
66         for (AdjVNode *w = graph->G[v]; w; w = w->next) {
67             if (!vis[w->adjVer]) {
68                 q.push(w->adjVer);
69                 vis[w->adjVer] = true;
70                 cnt++;
71             }
72         }
73         if (v == last) {
74             depth++;
75             last = q.back();
76         }
77     }
78     
79     return cnt;
80 }

 1 #include <cstdio>
 2 #include <queue>
 3 
 4 struct AdjVNode {
 5     int adjVer;
 6     AdjVNode *next;
 7 };
 8 
 9 struct LGraph {
10     AdjVNode **G;
11     int verN, edgeN;
12 };
13 
14 LGraph *createLGraph(int n, int m);
15 int BFS(LGraph *graph, int src);
16 
17 int main() {
18     int n, m;
19     scanf("%d %d", &n, &m);
20     LGraph *graph = createLGraph(n, m);
21     
22     for (int v = 0; v < graph->verN; v++) {
23         int cnt = BFS(graph, v);
24         printf("%d: %.2f%%\n", v + 1, 100.0 * cnt / graph->verN);
25     }
26     
27     return 0;
28 }
29 
30 LGraph *createLGraph(int n, int m) {
31     LGraph *graph = new LGraph;
32     graph->verN = n;
33     graph->edgeN = m;
34     graph->G = new AdjVNode*[graph->verN];
35     for (int v = 0; v < graph->verN; v++) {
36         graph->G[v] = NULL;
37     }
38     
39     for (int i = 0; i < graph->edgeN; i++) {
40         int v, w;
41         scanf("%d %d", &v, &w);
42         AdjVNode *tmp = new AdjVNode;
43         tmp->adjVer = w - 1;
44         tmp->next = graph->G[v - 1];
45         graph->G[v - 1] = tmp;
46         
47         tmp = new AdjVNode;
48         tmp->adjVer = v - 1;
49         tmp->next = graph->G[w - 1];
50         graph->G[w - 1] = tmp;
51     }
52     
53     return graph;
54 }
55 
56 int BFS(LGraph *graph, int src) {
57     bool vis[graph->verN] = {false};
58     int depth = 0, cnt = 1;
59     std::queue<int> q;
60     q.push(src);
61     vis[src] = true;
62     q.push(-1);
63     
64     while (!q.empty() && depth < 6) {
65         int v = q.front();
66         q.pop();
67         if (v == -1) {
68             depth++;
69             q.push(-1);
70             continue;
71         }
72         
73         for (AdjVNode *w = graph->G[v]; w; w = w->next) {
74             if (!vis[w->adjVer]) {
75                 q.push(w->adjVer);
76                 vis[w->adjVer] = true;
77                 cnt++;
78             }
79         }
80     }
81     
82     return cnt;
83 }

参考资料

　　浙江大学——数据结构：https://www.icourse163.org/course/ZJU-93001?tid=1461682474

　　[小白向]PTA 06-图3 六度空间 (30分)DFS通过测试点4：https://blog.csdn.net/yine100320/article/details/107959177

posted @ 2021-04-14 17:05 onlyblues 阅读(1366) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

onlyblues

六度空间

六度空间

输入格式:

输出格式:

输入样例:

输出样例:

解题思路

参考资料

公告