###### 数据结构---图

DFS和BFS是两种用途极广的工具。

### 输入样例1:

6 10
1 2
2 3
3 1
4 5
5 6
6 4
1 4
1 6
3 4
3 6


### 输出样例1:

1


### 输入样例2:

5 8
1 2
1 3
2 3
2 4
2 5
5 3
5 4
3 4


### 输出样例2:

0


1）对于无向图是否联通，采用并查集判断

2）此外还要判断顶点度数

#include <iostream>
#include <stdio.h>
using namespace std;
const int MAXN = 1002;
int root[MAXN];
int d[MAXN];
int Find(int x);
int main()
{
int n, m;
int u, v;
scanf("%d%d", &n, &m);
int tmpn = n;
for(int i = 0; i <= n; ++i)
root[i] = i;
for(int i = 0; i < m; ++i)
{
scanf("%d%d", &u, &v);
d[u]++, d[v]++;
int x = Find(u);
int y = Find(v);
if(x != y)
{
root[y] = x;
tmpn--;
}
}
if(tmpn != 1) printf("0\n"); //是否最后合并为一个组
else
{
int i;
for(i = 1; i <= n; ++i)
if(d[i]%2) break; //是否全是偶数度数
if(i > n) printf("1\n");
else printf("0\n");
}
return 0;
}
int Find(int x)
{
if(x != root[x])
root[x] = Find(root[x]);
return root[x];
}

### 输入样例1:

6 8 1
1 2
2 3
3 4
4 5
5 6
6 4
3 6
1 5


### 输出样例1:

1 2 3 4 5 6 5 4 3 2 1


### 输入样例2:

6 6 6
1 2
1 3
2 3
5 4
6 5
6 4


### 输出样例2:

6 4 5 4 6 0


#include <iostream>
using namespace std;
const int MAXN = 1002;
bool Map[MAXN][MAXN];
bool vis[MAXN];
void DFS(int s, int n, bool isfirst);
int main()
{
int n, m, s;
int u, v;
scanf("%d%d%d", &n, &m, &s);
for(int i = 0; i < m; ++i)
{
scanf("%d%d", &u, &v);
Map[u][v] = Map[v][u] = true;
}
vis[s] = true;
DFS(s, n, true);
for(int i = 1; i < n; ++i)
{
if(!vis[i])
{
printf(" 0");
break;
}
}
printf("\n");
return 0;
}
void DFS(int s, int n, bool isfirtst)
{
if(!isfirtst) printf(" ");
else isfirtst = false;
printf("%d", s);
for(int i = 1; i <= n; ++i)
{
if(Map[s][i] && !vis[i])
{
vis[i] = true;
Map[s][i] = Map[i][s] = false;
DFS(i, n, isfirtst);
printf(" %d", s); //表示返回又经过i点
}
}
}

Saving James Bond - Easy Version   (25分)

This time let us consider the situation in the movie "Live and Let Die" in which James Bond, the world's most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape -- he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head... Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).

Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him whether or not he can escape.

### Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integersNN (≤100\le 100), the number of crocodiles, and DD, the maximum distance that James could jump. Then NN lines follow, each containing the (x,y)(x, y) location of a crocodile. Note that no two crocodiles are staying at the same position.

### Output Specification:

For each test case, print in a line "Yes" if James can escape, or "No" if not.

### Sample Input 1:

14 20
25 -15
-25 28
8 49
29 15
-35 -2
5 28
27 -29
-8 -28
-20 -35
-25 -20
-13 29
-30 15
-35 40
12 12


### Sample Output 1:

Yes


### Sample Input 2:

4 13
-12 12
12 12
-12 -12
12 -12


### Sample Output 2:

No


#include <iostream>
#include <math.h>
using namespace std;
const int MAXN = 102;
struct point{
double x, y;
double dis(const struct point px) {
double xx = x - px.x;
double yy = y - px.y;
return sqrt(xx * xx + yy * yy);
}
}p[MAXN];
bool vis[MAXN];
bool DFS(int s, int n, double d);
int main()
{
int n, i;
double d;
scanf("%d%lf", &n, &d);
p[0].x = p[0].y = 0;
for(i =1; i <= n; ++i)
scanf("%lf%lf", &p[i].x, &p[i].y);
vis[0] = true;
if(p[0].x + d + 7.5 >= 50 || -p[0].x + d + 7.5 >= 50)
printf("Yes\n");
else if(p[0].y + d + 7.5 >= 50 || -p[0].y + d +7.5 >= 50)
printf("Yes\n");
else //以上判断是否一下就能到岸，只要在跳跃范围内就算能到终点
{
for(i = 1; i <= n; ++i) //寻找一条通路
{
if(!vis[i] && p[0].dis(p[i]) <= d + 7.5) //是否在跳跃范围内
{
vis[i] = true;
if(DFS(i, n, d))
{
printf("Yes\n");
break;
}
else vis[i] = false;
}
}
if(i > n) //如果所有情况都不能跳出
printf("No\n");
}
return 0;
}
bool DFS(int s, int n, double d)
{
double D = d;
struct point tmp = p[s];
if(tmp.x + D >= 50 || -tmp.x + D >= 50)
return true;
if(tmp.y + D >= 50 || -tmp.y + D >= 50)
return true;
for(int i = 1; i <= n; ++i)
{
if(!vis[i] && tmp.dis(p[i]) <= D) //是否在跳跃范围内
{
vis[i] = true;
if(DFS(i, n, D)) return true;
else vis[i] = false;
}
}
return false;
}

### 输入样例:

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


### 输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }


#include <iostream>
#include <stdio.h>
using namespace std;
const int MAXN = 12;
int Map[MAXN][MAXN];
void DoDFS(int n);
void DoBFS(int n);
void DFS(int n, int s, int *node);
void BFS(int n, int s, int *node);
int main()
{
int n, m;
int u, v;
cin>>n>>m;
for(int i = 0; i < m; ++i)
{
cin>>u>>v;
Map[u][v] = Map[v][u]= true;
}
DoDFS(n);
DoBFS(n);
return 0;
}
void DoDFS(int n)
{
int node[MAXN] = {false};
for(int i = 0; i < n; ++i) //尝试每一个结点，并寻找出该点所在的连通集
{
if(!node[i]) //如果该点未遍历
{
node[i] = true;
printf("{ %d", i);
DFS(n, i, node);
printf(" }\n");
}
}
}
void DFS(int n, int s, int *node)
{
for(int i = 0; i < n; ++i)
{
if(!node[i] && Map[s][i])
{
node[i] = true;
printf(" %d", i);
DFS(n, i, node);
}
}
}
void DoBFS(int n)
{
int node[MAXN] = {false};
for(int i = 0; i < n; ++i) //同样尝试各个结点
{
if(!node[i])
{
printf("{");
BFS(n, i, node);
printf(" }\n");
}
}
}
void BFS(int n, int s, int *node)
{
int q[MAXN] = {0}, f = 0, e = 0;
node[s] = true;
q[e++] = s;
while(f < e)
{
int tmp = q[f++];
printf(" %d", tmp);
for(int i = 0; i < n; ++i)
{
if(!node[i] && Map[tmp][i])
{
node[i] = true;
q[e++] = i;
}
}
}
}

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


#include <iostream>
#include <stdio.h>
using namespace std;
const int MAXN = 10002;
bool Map[MAXN][MAXN] = {false};
int BFS(int s, int n);
int main()
{
int n, m;
int u, v;
scanf("%d%d", &n, &m);
for(int i = 0; i < m; ++i)
{
scanf("%d%d",&u,&v);
Map[u][v] = Map[v][u] = true;
}
for(int i = 1; i <= n; ++i)
{
int node = BFS(i, n);
printf("%d: %.2lf%%\n", i, 100.0 * node / n);
}
return 0;
}
int BFS(int s, int n)
{
int q[MAXN] = {0}, len[MAXN] = {0};
int f = 0, e = 0, tmp;
bool vis[MAXN] = {false};
q[e++] = s;
vis[s] = true;
while(f < e)
{
tmp = q[f++];
if(len[e - 1] > 6) break; //是否在题设范围内
for(int i = 0; i <= n; ++i)
{
if(!vis[i] && Map[tmp][i])
len[e] = len[f - 1] + 1, q[e++] = i, vis[i] = true;
}
}
for(tmp = 0; tmp < e && len[tmp] < 7; ++tmp);
return tmp;
}

“紧密度中心性”是用来衡量一个结点到达其它结点的“快慢”的指标，即一个有较高中心性的结点比有较低中心性的结点能够更快地（平均意义下）到达网络中的其它结点，因而在该网络的传播过程中有更重要的价值。在有NN个结点的网络中，结点viv_i的“紧密度中心性”Cc(vi)Cc(v_i)数学上定义为viv_i到其余所有结点vjv_j (j≠ij\ne i) 的最短距离d(vi,vj)d(v_i, v_j)的平均值的倒数：

### 输入样例:

9 14
1 2
1 3
1 4
2 3
3 4
4 5
4 6
5 6
5 7
5 8
6 7
6 8
7 8
7 9
3 3 4 9


### 输出样例:

Cc(3)=0.47
Cc(4)=0.62
Cc(9)=0.35


#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
const int MAXN = 10002;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int dis[MAXN];
void dijkstral(int s, int n); //迪杰斯特拉算法
int main()
{
int n, m, k;
int u, v;
bool islink = true;
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= n; ++j)
Map[i][j] = INF;
for(int i = 0; i < m; ++i)
{
scanf("%d%d", &u, &v);
Map[u][v] = Map[v][u] = true;
}
scanf("%d", &k);
for(int i = 0; i < k; ++i)
{
scanf("%d", &u);
dijkstral(u, n); //求各个点到点u的距离
int sum = 0;
for(int i = 1; i <= n && islink; ++i)
{
if(dis[i] == INF) //如果与某个点不连通
{
sum = 0, islink = false;
break;
}
sum += dis[i];
}
if(islink) //判断是否连通
printf("Cc(%d)=%.2lf\n", u, 1.0 * (n - 1) / sum);
else
printf("Cc(%d)=0.00\n", u);
}
return 0;
}
void dijkstral(int s, int n)
{
bool vis[n];
for(int i = 1; i <= n; ++i)
vis[i] = false,	dis[i] = Map[s][i];
vis[s] = true;
dis[s] = 0;
for(int i = 1; i < n; ++i)
{
int Min = INF, index = s;
for(int j = 1; j <= n; ++j)
if(!vis[j] && Min > dis[j])
Min = dis[j], index = j;
vis[index] = true;
for(int j = 1; j <= n; ++j)
if(!vis[j] && dis[j] > dis[index] + Map[index][j])
dis[j] = dis[index] + Map[index][j];
}
}

### 输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3


### 输出样例:

12


1）判断是否连通，此处采用并查集

2）如果连通，则输出结果

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
const int MAXN = 1002;
struct edge{
int u, v;
int cost;
bool operator <(const struct edge E) const{
return cost < E.cost;
}
}e[MAXN * 3];
int root[MAXN];
int F(int x);
int main()
{
int n, m;
int cost = 0;
scanf("%d%d", &n, &m);
for(int i = 0; i <= n; ++i)
root[i] = i;
for(int i = 0; i < m; ++i)
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].cost);
sort(e, e + m);//以下是Kruskal算法
for(int i = 0; i < m; ++i)
{
int x = F(e[i].u);
int y = F(e[i].v);
if(x != y)
{
cost += e[i].cost;
root[y] = x;
}
}//以下是判断是否连通
for(int i = 1; i <= n; ++i)
F(i);
int tmp = root[1];
for(int i = 2; i <= n; ++i)
if(tmp != root[i]) tmp = -1;
if(tmp > 0)
printf("%d\n", cost);
else
printf("-1\n");
return 0;
}
int F(int x)
{
if(x != root[x])
root[x] = F(root[x]);
return root[x];
}

### 输入样例:

4
1 2 1 1
1 3 4 0
1 4 1 1
2 3 3 0
2 4 2 1
3 4 5 0


### 输出样例:

3


#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
const int MAXN = 4990;
struct infi{
int u, v;
int cost;
bool operator <(const struct infi l) const{
return cost < l.cost;
}
}line[MAXN];
int root[MAXN];
int Find(int x);
int main()
{
int n, tmpn, e;
int u, v, cost, index = 0, totCost = 0, isbuild;
scanf("%d", &n);
tmpn = n, e = n * (n - 1) / 2;
for(int i = 0; i <= n; ++i)
root[i] = i;
for(int i = 0; i < e; ++i)
{
scanf("%d %d %d %d", &u, &v, &cost, &isbuild);
if(isbuild)
{
int x = Find(u);
int y = Find(v);
if(x != y)
tmpn--, root[y] = x;
}
else
{
line[index].u = u, line[index].v = v;
line[index].cost = cost, index++;
}
}
sort(line, line + index);
for(int i = 0; i < index && tmpn > 1; ++i)
{
int x = Find(line[i].u);
int y = Find(line[i].v);
if(x != y)
{
totCost += line[i].cost;
root[y] = x;
tmpn--;
}
}
printf("%d\n", totCost);
return 0;
}
int Find(int x)
{
if(x != root[x])
root[x] = Find(root[x]);
return root[x];
}

### 输入样例:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20


### 输出样例:

3 40


#include <iostream>
#include <stdio.h>
using namespace std;
const int MAXN = 504;
const int INF = (1<<30);
struct infi{
int len, cost;
}city[MAXN][MAXN], ans;
void shortpath(int n, int s, int d);
int main()
{
int n, m, s, d;
int u, v, l, c;
scanf("%d%d%d%d", &n, &m, &s, &d);
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
city[i][j].len = city[i][j].cost = INF; //初始化
for(int i = 0; i < m; ++i) //读入信息
{
scanf("%d%d%d%d", &u, &v, &l ,&c);
city[u][v].len = city[v][u].len = l;
city[u][v].cost = city[v][u].cost = c;
}
shortpath(n, s, d);
printf("%d %d\n", ans.len, ans.cost);
return 0;
}
void shortpath(int n, int s, int d)
{
int dis[MAXN], cost[MAXN] = {0};
bool vis[MAXN] = {false};
for(int i = 0; i < n; ++i) //初始化待求权值
dis[i] = city[s][i].len, cost[i] = city[s][i].cost;
vis[s] = true, dis[s] = 0, cost[s] = 0;
for(int i = 1; i < n; ++i)
{
int Mindis = INF, Mincost = INF, index = s;
for(int j = 0; j < n; ++j)
{
if(Mindis > dis[j] && !vis[j])
{
Mindis = dis[j];
Mincost = cost[j];
index = j;
}
}
for(int j = 0; j < n; ++j)
{
if(!vis[j] && Mindis == dis[j] && Mincost > cost[j])
Mincost = cost[j], index = j;
} //以上是求得最小的权值的结点，将其并入已访问的集合
vis[index] = true;
for(int j = 0; j < n; ++j)
{
if(!vis[j])
{
if(dis[index] + city[index][j].len < dis[j]) //动态更新权值
{
dis[j] = dis[index] + city[index][j].len;
cost[j] = cost[index] + city[index][j].cost;
}
else if(dis[index] + city[index][j].len == dis[j])
{
if(cost[index] + city[index][j].cost < cost[j])
{
cost[j] = cost[index] + city[index][j].cost;
}
}
}
}
}
ans.len = dis[d], ans.cost = cost[d];
}

### 输入样例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80


### 输出样例:

4 70


#include <iostream>
#include <stdio.h>
const int MAXN = 102;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int shortpath(int s, int n);
int main()
{
int n, m;
int u, v, dis;
int Min = INF, index = 1;
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= n; ++j)
Map[i][j] = Map[j][i] = INF;
for(int i = 0; i < m; ++i)
{
scanf("%d%d%d", &u, &v, &dis);
Map[u][v] = Map[v][u] = dis;
}
for(int i = 1; i <= n; ++i) //选择对应魔咒最短的动物
{
int tmp = shortpath(i, n);
if(tmp < Min)
{
Min = tmp;
index = i;
}
}
if(Min != INF)
printf("%d %d\n", index, Min);
else
printf("0\n");
return 0;
}
int shortpath(int s, int n)
{
int dis[MAXN], Max = 0;
bool vis[MAXN] = {false};
for(int i = 1;i <= n; ++i)
dis[i] = Map[s][i];
vis[s] = true, dis[s] = 0;
for(int i  = 1; i < n; ++i)
{
int Min = INF, index = s;
for(int j = 1; j <= n; ++j)
{
if(!vis[j] && dis[j] < Min)
{
Min = dis[j], index = j;
}
}
vis[index] = true;
for(int j = 1; j <= n; ++j)
{
if(!vis[j] && dis[j] > dis[index] + Map[index][j])
{
dis[j] = dis[index] + Map[index][j];
}
}
}
for(int i = 1; i <= n; ++i) //选择最长的魔咒
{
Max = Max > dis[i]? Max: dis[i];
}
return Max;
}

### 输入样例:

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2


### 输出样例:

2 60
0 1 3


/*
STL:
http://blog.csdn.net/qq_26437925/article/category/5731279/2
*/
#include <iostream>
using namespace std;
const int MAXN = 504;
const int INF = (1<<30);
int Map[MAXN][MAXN];
int team[MAXN];
void dijkstral(int s, int d, int n);
int main()
{
int n, m, s, d;
int u, v, dis;
scanf("%d%d%d%d", &n, &m, &s, &d);
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
Map[i][j] = Map[j][i] = INF;
for(int i = 0; i < n; ++i)
scanf("%d", &team[i]);
for(int i = 0; i < m; ++i)
{
scanf("%d%d%d", &u, &v, &dis);
Map[u][v] = Map[v][u] = dis;
}
dijkstral(s, d, n);
return 0;
}
void dijkstral(int s, int d, int n)
{
int dis[MAXN], peo[MAXN], pre[MAXN], plen[MAXN];
int road[MAXN], way[MAXN];
bool vis[MAXN];
for(int i = 0; i < n; ++i)
{
if(Map[s][i] != INF) way[i] = 1;
else way[i] = 0;
dis[i] = Map[s][i];
vis[i] = false;
peo[i] = team[i] + team[s], pre[i] = s, plen[i] = 1;
}
dis[s] = 0, vis[s] = true, way[s] = 0;
peo[s] = team[s], pre[s] = -1, plen[s] = 0;
for(int i = 1; i < n; ++i)
{
int Mindis = INF, Maxpeo = 0, index = s;
for(int j = 0; j < n; ++j)
{
if(!vis[j] && Mindis > dis[j])
Mindis = dis[j], index = j;
else if(!vis[j] && Mindis == dis[j] && Maxpeo < peo[j])
Maxpeo = peo[j], index = j;
}
vis[index] = true;
for(int j = 0; j < n; ++j)
{
if(!vis[j] && dis[j] > dis[index] + Map[index][j])
{
way[j] = way[index]; //到达j点，最多有way[index]条最短路
pre[j] = index, plen[j] = plen[index] + 1;
dis[j] = dis[index] + Map[index][j];
peo[j] = peo[index] + team[j];
}
else if(!vis[j] && dis[j] == dis[index] + Map[index][j])
{
way[j] += way[index]; //如果相同，则加上way[index]条新的方式
if(peo[j] < peo[index] + team[j])
{
pre[j] = index, plen[j] = plen[index] + 1;
peo[j] = peo[index] + team[j];
}
}
}
s = index;
}
s = d;
for(int i = 0; i < plen[d]; ++i) //得到城市编号
road[i] = pre[s], s = pre[s];
printf("%d %d\n", way[d], peo[d]);
for(int i = plen[d] - 1; i >= 0; --i)
printf("%d ", road[i]);
printf("%d\n", d);
}

### 输入样例1:

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


### 输出样例1:

1


### 输入样例2:

5
1 4
2 1 4
2 2 5
1 3
0


### 输出样例2:

0


#include <iostream>
#include <stdio.h>
using namespace std;
const int MAXN = 102;
struct infi{
int v;
struct infi *next;
}*node[MAXN]; //用邻接表表示图
int Indegree[MAXN];
int q[MAXN];
int main()
{
int n, m;
int f = 0, e = 0, cnt = 0;
scanf("%d", &n);
for(int i = 0; i <= n; ++i)
{
node[i] = new struct infi;
node[i]->next = NULL, node[i]->v = i;
}
for(int i = 1; i <= n; ++i)
{
scanf("%d", &m);
struct infi* tail = node[i];
for(int i = 0; i < m; ++i)
{
struct infi *tmp = new struct infi;
tmp->next = NULL;
scanf("%d", &tmp->v);
tail->next = tmp;
tail = tmp;
Indegree[tmp->v]++; //记录入度
}
}
for(int i = 1; i <= n; ++i) //拓扑排序
if(Indegree[i] == 0)
q[e++] = i;
while(f < e)
{
int v = q[f++];
struct infi *head = node[v]->next;
cnt++;
while(head)
{
Indegree[head->v]--;
if(Indegree[head->v] == 0)
q[e++] = head->v;
struct infi *tmp = head;
head = head->next;
delete tmp;
}
}
if(cnt < n) printf("0\n");
else printf("1\n");
return 0;
}

#### MOOC浙大数据结构 — 06-图3 六度空间 (30分)

2016-11-21 10:36:42

#### 六度空间

2016-01-27 21:55:39

#### 06-图3 六度空间 (30分)

2016-11-06 11:29:15

#### 7-1 六度空间（30 分）

2017-10-07 15:18:06

#### PTA 7-12（图） 社交网络图中结点的“重要性”计算（30 分） 30分代码

2017-10-04 20:11:12

#### 7-36 社交网络图中结点的“重要性”计算（30 分）

2017-09-27 12:04:21

#### 5-36 社交网络图中结点的“重要性”计算 (30分)

2016-08-30 11:35:08

#### PTA 7-12 社交网络图中结点的“重要性”计算

2017-10-25 00:47:16

#### PTA-数据结构 5-36 社交网络图中结点的“重要性”计算 (30分)

2016-11-29 19:45:40

#### Java中的访问控制

2012-01-10 01:50:41