A - 氪金带东
题目
实验室里原先有一台电脑(编号为1)，最近氪金带师咕咕东又为实验室购置了N-1台电脑，编号为2到N。每台电脑都用网线连接到一台先前安装的电脑上。但是咕咕东担心网速太慢，他希望知道第i台电脑到其他电脑的最大网线长度，但是可怜的咕咕东在不久前刚刚遭受了宇宙射线的降智打击，请你帮帮他。
提示: 样例输入对应这个图，从这个图中你可以看出，距离1号电脑最远的电脑是4号电脑，他们之间的距离是3。 4号电脑与5号电脑都是距离2号电脑最远的点，故其答案是2。5号电脑距离3号电脑最远，故对于3号电脑来说它的答案是3。同样的我们可以计算出4号电脑和5号电脑的答案是4.
Input
输入文件包含多组测试数据。对于每组测试数据，第一行一个整数N (N<=10000)，接下来有N-1行，每一行两个数，对于第i行的两个数，它们表示与i号电脑连接的电脑编号以及它们之间网线的长度。网线的总长度不会超过10^9，每个数之间用一个空格隔开。
Output
对于每组测试数据输出N行，第i行表示i号电脑的答案 (1<=i<=N).
Sample Input
5
1 1
2 1
3 1
1 1
Sample Output
3
2
3
4
4
做法
树的直径问题——树的直径一定是某两个叶子节点之间的距离。求树的直径:从树中任选一个点开始遍历这棵树，找到一个距离这个点最远的叶子，然后再从这个叶子开始遍历，找到离这个叶子最远的另一个叶子，它们之间的距离就是树的直径。 即两次遍历就可求树的直径。
回到本题，假设树的最长路的两个叶子节点为v1，v2，从任意一点u出发走到的最远点一定是（v1，v2）中的一点，然后再从v1或者v2出发走到的最远点一定是v2或者v1。找某个节点x所能到达的最长路径，这个最长路径要么是到v1的路径，要么是到v2的路径。
代码分析 ，用结构体edge类型的vector数组G储存加权边。利用bfs求最长路径。bfs函数引入一个参数e作为起点，将e到达点i的距离储存在数组dis中。
第一次bfs从1开始，找到一个叶子节点v1。
第二次bfs从这个叶子节点v1开始，找到另一个叶子节点v2，同时将v1到达各点的距离储存在数组dis2中。
第三次bfs从v2出发，将到达各点的距离储存在数组dis1中。
最后取dis1[i]和dis2[i]中的较大值，找到最大网线长度。
代码
#include<iostream>
#include<vector>
#include<queue>
#include<string.h>
#include<stdio.h>
using namespace std;
struct edge
{
int v,w;
};
vector<edge> G[10100];
int dis3[10100];
int dis2[10100];//用于记录一点到其他点的距离
int dis1[10100];
int mark[10100];
void bfs(int e,int n,int *dis)//e起点
{
for(int i=0;i<=n;i++)
{
mark[i]=0;
dis[i]=0;
}
queue<int> q;
q.push(e);
mark[e]=1;
while(!q.empty())
{
int s=q.front();
q.pop();
for(int i=0;i<G[s].size();i++)
{
if(mark[G[s][i].v]==0)
{
mark[G[s][i].v]=1;
q.push(G[s][i].v);
dis[G[s][i].v]=dis[s]+G[s][i].w;
}
}
}
}
int k=0,maxx;
int distance(int n,int *dis)//找出dis最大距离
{
maxx=0;
for(int i=1;i<=n;i++)
{
if(maxx<dis[i])
{
maxx=dis[i];
k=i;
}
}
return k;//此时k就是距离该点最近的点
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
for(int i=0;i<=n;i++)
G[i].clear();
for(int i=2;i<=n;i++)
{
int a,b;
//cin>>a>>b;
scanf("%d%d",&a,&b);
edge c;
c.v=a;
c.w=b;
G[i].push_back(c);
c.v=i;
G[a].push_back(c);
}
bfs(1,n,dis3);//用1节点找到一个叶子节点
int leaf1,leaf2;
leaf1=distance(n,dis3);
bfs(leaf1,n,dis2);//找到另一个叶子
leaf2=distance(n,dis2);
bfs(leaf2,n,dis1);
for(int i=1;i<=n;i++)
{
if(dis2[i]>dis1[i])
cout<<dis2[i]<<endl;
else
cout<<dis1[i]<<endl;
}
}
return 0;
}
B - 戴好口罩
题目
新型冠状病毒肺炎（Corona Virus Disease 2019，COVID-19），简称“新冠肺炎”，是指2019新型冠状病毒感染导致的肺炎。
如果一个感染者走入一个群体，那么这个群体需要被隔离！
小A同学被确诊为新冠感染，并且没有戴口罩！！！！！！
危！！！
时间紧迫！！！！
需要尽快找到所有和小A同学直接或者间接接触过的同学，将他们隔离，防止更大范围的扩散。
众所周知，学生的交际可能是分小团体的，一位学生可能同时参与多个小团体内。
请你编写程序解决！戴口罩！！
Input
多组数据，对于每组测试数据：
第一行为两个整数n和m（n = m = 0表示输入结束，不需要处理），n是学生的数量，m是学生群体的数量。0 < n <= 3e4 ， 0 <= m <= 5e2
学生编号为0~n-1
小A编号为0
随后，m行，每行有一个整数num即小团体人员数量。随后有num个整数代表这个小团体的学生。
Output
输出要隔离的人数，每组数据的答案输出占一行
Sample Input
100 4
2 1 2
5 10 13 11 12 14
2 0 1
2 99 2
200 2
1 5
5 1 2 3 4 5
1 0
0 0
Sample Output
4
1
1
做法
并查集
数组par表示元素所在集合的代表元素的编号。查询节点代表元素利用递归实现，查询的同时实现路径压缩。
合并时把一个分组的根挂到另一个分组，好的策略是小树挂大树上，用一个数组rank维护当前集合的大小。
该题只需要简单的将集合合并，然后找到0号元素的代表元，输出其对应的集合大小rank即可。
代码
#include<iostream>
#include<stdio.h>
using namespace std;
int par[40000];
int rank[40000];//维护当前集合的大小
int find(int x)
{
if(par[x]==x)
return x;
return par[x]=find(par[x]);
}
bool unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y)
return false;
if(rank[x]>rank[y])
{
par[y]=x;
rank[x]=rank[y]+rank[x];
}
else
{
par[x]=y;
rank[y]=rank[x]+rank[y];
}
return true;
}
int main()
{
int n,m;
while(scanf("%d%d",&n,&m))
{
if(n==0&&m==0)
break;
for(int i=0;i<n;i++)
{
par[i]=i;
rank[i]=1;
}
for(int i=0;i<m;i++)
{
int num;
scanf("%d",&num);
int a;
scanf("%d",&a);
for(int j=1;j<num;j++)
{
int b;
scanf("%d",&b);
unite(a,b);
}
}
cout<<rank[find(0)]<<endl;
}
return 0;
}
C - 掌握魔法の东东 I
题目
东东在老家农村无聊，想种田。农田有 n 块，编号从 1~n。种田要灌氵
众所周知东东是一个魔法师，他可以消耗一定的 MP 在一块田上施展魔法，使得黄河之水天上来。他也可以消耗一定的 MP 在两块田的渠上建立传送门，使得这块田引用那块有水的田的水。 (1<=n<=3e2)
黄河之水天上来的消耗是 Wi，i 是农田编号 (1<=Wi<=1e5)
建立传送门的消耗是 Pij，i、j 是农田编号 (1<= Pij <=1e5, Pij = Pji, Pii =0)
东东为所有的田灌氵的最小消耗
Input
第1行：一个数n
第2行到第n+1行：数wi
第n+2行到第2n+1行：矩阵即pij矩阵
Output
东东最小消耗的MP值
Example
Input
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
Output
9
做法
kruskal最小生成树，可以加一个超级源点0，向n个边连为wi，然后就可以通过对这个图求最小生成树来解决问题。最小生成树的总权重即为所求的最小消耗。
利用并查集实现kruskal。先按权重将各边升序排序，每次取出最小的边，若边的两点不属于同一集合，就可以选中这个边，并把这个边连的两个集合合并。
代码
#include<iostream>
#include<algorithm>
using namespace std;
struct edge
{
int u,v,w;
bool operator<(edge a)
{
return w<a.w;
}
}e[101000];
int par[1100];
int find(int x)
{
if(par[x]==x)
return x;
return par[x]=find(par[x]);
}
bool unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y)
return false;
par[y]=x;
return true;
}
int main()
{
int n;
cin>>n;
int k=0;
par[0]=0;
for(int i=1;i<=n;i++)
{
e[k].u=0;
e[k].v=i;
scanf("%d",&e[k].w);
k++;
par[i]=i;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
int t;
scanf("%d",&t);
if(i<j)
{
e[k].u=i;
e[k].v=j;
e[k].w=t;
k++;
}
}
}
//kruskal
sort(e,e+k);
int edgenum=k;
int num=0;
int j=0;//e的下标
int weight=0;//生成树的权重
while(edgenum>0&&num<n)
{
int a=find(e[j].u);
int b=find(e[j].v);
if(a!=b)
{
weight+=e[j].w;
unite(a,b);
num++;
}
j++;
edgenum--;
}
cout<<weight<<endl;
return 0;
}
D - 数据中心
Example
Input
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2
Output
4
做法
kruskal求最小生成树，与C题类似。求网络图的最小生成树，生成树中权值最大的边就是所求耗时。
代码
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
struct edge
{
int u,v,w;
bool operator<(const edge &t)
{
return w<t.w;
}
}e[100100];
int par[100100];
int find(int x)
{
if(par[x]==x)
return x;
return par[x]=find(par[x]);
}
bool unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y)
return false;
par[y]=x;
return true;
}
int main()
{
int n,m,root;
cin>>n>>m>>root;
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
}
for(int i=0;i<=n;i++)
{
par[i]=i;
}
//kruskal
sort(e,e+m);
int ans=0;
int k=0;
int ed=m;
int j=0;
while(ed>0&&k<n-1)
{
int x=find(e[j].u);
int y=find(e[j].v);
ed--;
if(x!=y)
{
unite(x,y);
k++;
if(ans<e[j].w)
ans=e[j].w;
}
j++;
}
cout<<ans<<endl;
return 0;
}
147
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
