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 1Sample Output
3
2
3
4
4解题思路
这道题要求每个节点所能到达的最长路径长度，首先要明确的是，一共输入n-1条边，因此所有的电脑形成一颗树，也就是说图中不存在环路！
我们先回忆上课讲过的求树的直径的方法。那么假如我们已经知道了树的直径（即树内最长的边），它的两个顶点分别为v1，v2。那么从任一点u出发能走到的最远的点一定是v1,v2中的一个。既然已经知道一定是v1,v2中的一个，那当我们分别从v1,v2开始遍历，记录v1,v2到每个点的距离（也即每个点分别到v1,v2的距离），再回忆上面的思想——从任一点u出发能走到的最远的点一定是v1,v2中的一个。此时再比较每个点到v1,v2的距离，较大的就是每个节点所能到达的最长路径长度。
注意
这里存图我采用的是链式前向星。dfs遍历过程中要注意用该点到前一点的距离去更新该点到后一点的距离，因为这里是树结构，两个点之间的路径有且仅有一条；由于是无向图，同一条边存了两次，所以可以用flag[]数组来避免同一点访问多次造成死循环。
树直径的求法：从树中任选一个点开始遍历这棵树，找到一个距离这个点最远的叶子，然后再从这个叶子开始遍历，找到离这个叶子最远的另一个叶子，他们之间的距离就是树的直径，这两片叶子就是直径顶点。
代码
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define MAXN 10010
using namespace std;
struct Edge {
int u,v,w,nxt;
}e[2*MAXN];
int n,v1,v2,ans;
int head[MAXN],tot;
int dis1[MAXN],dis_v1[MAXN],dis_v2[MAXN];
bool flag[MAXN];
void addEdge(int u,int v,int w) {
e[tot].u=u;
e[tot].v=v;
e[tot].w=w;
e[tot].nxt=head[u];
head[u]=tot;
tot++;
}
void dfs1(int u) {
if(flag[u]) return;//这一句可不要，只有判断了flag为0（未到）才会向后遍历
flag[u]=1;
for(int i=head[u];i!=-1;i=e[i].nxt) {
int v=e[i].v;
if(!flag[v]) {
dis1[v]=dis1[u]+e[i].w;
if(dis1[v]>ans) {
v1=v;
ans=dis1[v];
}
dfs1(v);
}
}
}
void dfs_v1(int u) {
if(flag[u]) return;//这一句可不要，只有判断了flag为0（未到）才会向后遍历
flag[u]=1;
for(int i=head[u];i!=-1;i=e[i].nxt) {
int v=e[i].v;
if(!flag[v]) {
dis_v1[v]=dis_v1[u]+e[i].w;
if(dis_v1[v]>ans) {
v2=v;
ans=dis_v1[v];
}
dfs_v1(v);
}
}
}
void dfs_v2(int u) {
if(flag[u]) return;//这一句可不要，只有判断了flag为0（未到）才会向后遍历
flag[u]=1;
for(int i=head[u];i!=-1;i=e[i].nxt) {
int v=e[i].v;
if(!flag[v]) {
dis_v2[v]=dis_v2[u]+e[i].w;
dfs_v2(v);
}
}
}
int main() {
while(scanf("%d",&n)!=EOF) {//每组数据执行前要更新所有数组
memset(dis1,0,sizeof(dis1));
memset(dis_v1,0,sizeof(dis_v1));
memset(dis_v2,0,sizeof(dis_v2));
memset(head,-1,sizeof(head));
int v,w;tot=0;
for(int i=2;i<=n;++i) {
scanf("%d %d",&v,&w);
addEdge(i,v,w);
addEdge(v,i,w);
}
//每次遍历访问前要更新ans和flag
ans=0;memset(flag,0,sizeof(flag));dfs1(1);
ans=0;memset(flag,0,sizeof(flag));dfs_v1(v1);
ans=0;memset(flag,0,sizeof(flag));dfs_v2(v2);
for(int i=1;i<=n;++i)
printf("%d\n",max(dis_v1[i],dis_v2[i]));
}
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 0Sample Output
4
1
1解题思路
这道题是很明显的并查集问题。将与小A直接或间接接触过的所有学生并入同一个集合，用par[]维护每个学生的所属的集合，rnk[]维护每个学生所属集合的总人数，便于启发式unite同时最后可直接输出0号小A所属集合的总人数rnk[find(0)]（即需要被隔离的人数）。
注意
①并查集find()要注意路径压缩，unite()要注意启发式合并（有需要的话）
②输入前要注意par[]和rnk[]的初始化
③输入过程中每个小团体中的学生自动加入同一集合
代码
#include<iostream>
#include<cstdio>
using namespace std;
int par[30010],rnk[30010];
void init(int n) {
for(int i=0;i<n;++i) {
par[i]=i;
rnk[i]=1;
}
}
int find(int x) {
if(par[x]==x) return x;
//路径压缩
return par[x]=find(par[x]);
}
void unite(int x,int y) {
//启发式合并
if(rnk[x]>rnk[y]) swap(x,y);
par[x]=y;
rnk[y]=(rnk[x]+=rnk[y]);
}
int main() {
int n=0,m=0,num=0,x=0,y=0;
while(1) {
scanf("%d %d",&n,&m);
if(n==0&&m==0) break;
init(n);
while(m--) {
scanf("%d %d",&num,&x);
for(int i=1;i<num;++i) {
scanf("%d",&y);
x=find(x);
y=find(y);
//不在同一集合
if(x!=y) unite(x,y);//并入
}
}
printf("%d\n",rnk[find(0)]);
}
return 0;
}C-掌握魔法の东东！
题目描述
东东在老家农村无聊，想种田。农田有 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 0Output
9解题思路
如果把“黄河之水天上来”的操作删掉，这个题就是一个最小生成树的模板题。
第一眼见到这个题我们会疑惑，当一块田需要水时，我们该怎么在天上之水和沟渠之水中权衡呢？
这里我们可以换个思路，对于向一块田中引水，无论哪种操作，东东都会付出一定的魔法，而魔法的代价本质上没有任何区别，我们只需要求最终所需魔法和最小即可。
考虑图重构。我们将天上之水作为超级源点0号，并把天上水到n个点的所需魔法Wi作为边加入边表，然后对这n+1个点跑最小生成树即可。这里生成最小生成树使用的是Kruskal算法。
注意
我们生成最小生成树时，0号点一定会加入这棵树，即只要这棵树能连通，那么所有的田都能得到灌溉，满足要求。
将pij矩阵加入边表时，注意pii和pjj为0，不能加入。
代码
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n,ans,tot,cnt,par[310];
struct Edge{
int u,v,w;
bool operator<(const Edge &e) const {
return w<e.w;
}
}e[91000];
void init(int n) {
for(int i=0;i<=n;++i)
par[i]=i;
}
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[x]=y;
return true;
}
int main() {
int w=0;
scanf("%d",&n);
for(int i=1;i<=n;++i) {
scanf("%d",&w);
e[tot].u=0;
e[tot].v=i;
e[tot].w=w;
tot++;
}
for(int i=1;i<=n;++i) {
for(int j=1;j<=n;j++) {
scanf("%d",&w);
if(w!=0) {
e[tot].u=i;
e[tot].v=j;
e[tot].w=w;
tot++;
}
}
}
init(n);
sort(e,e+tot);
for(int i=0;i<tot;++i) {
if(unite(e[i].u,e[i].v)) {
ans+=e[i].w;
cnt++;
}
if(cnt==n) break;
}
printf("%d\n",ans);
return 0;
}D-数据中心
题目描述
Example
Input
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2Output
4解题思路
首先明确题意：无向图，有边权，求解最优树结构。“root节点只能接收数据，其余任何一个节点可以将数据传输给另外的一个节点，但是不能将数据传输给多个节点”。这个结构符合树的定义。root即为树的根节点，其他每个节点有到根的唯一通路，点之间不存在环路。最终的输出结构为一棵树，这棵树包含原图所有的点，因此是一棵生成树。那么我们现在要解决的就是——“求解一颗生成树，使得最大边权最小！”。
这里有两种解法：
①二分解法：不是要求最大值最小的问题吗？这就是很明显的二分问题了，通过二分答案ans，将问题转化为原图中不大于ans的边能否使原图连通（？No->ans++，Yes->ans–）。二分答案的复杂度为O(logK),判断连通性复杂度为O(N+M)，总复杂度为O((N+M)*logK)。
②最小瓶颈生成树：利用其性质，最小生成树一定是瓶颈生成树，直接求最小生成树，输出其最大边权即可。
注意
根据题意:
Tmax=max{Th}
Th=max{t h,j}
Tmax=max{t h,j},h为深度，j为与深度为h的点相连的边
认为所有的数据是同时传输的，即树中最大的边权值就是传输所需要的时间。因此我们本题答案就是这颗最优生成树的最大边权
瓶颈生成树的定义：对于无向图G，G的瓶颈生成树是一棵 “ 树上最大边权值 edge 在G的所有生成树中最小 ” 的生成树，这样的生成树可能不止一棵。
代码
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
struct Edge {
int u,v,w;
bool operator<(const Edge &e) const {
return w<e.w;
}
}e[100010];
int n,m,root,cnt,ans;
int par[50010];
void init(int n) {
for(int i=1;i<=n;++i)
par[i]=i;
}
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[x]=y;
return true;
}
int kruskal_return_max() {
sort(e+1,e+1+m);
for(int i=1;i<=m;++i) {
if(unite(e[i].u,e[i].v)) {
ans=max(ans,e[i].w);
cnt++;
}
if(cnt==n-1) break;
}
}
int main() {
scanf("%d%d%d",&n,&m,&root);
init(n);
for(int i=1;i<=m;++i)
scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
kruskal_return_max();
printf("%d\n",ans);
return 0;
}
