实验室有n台电脑，给出所有电脑连接的情况，求每个电脑到其他电脑的最大网线长度
样例输入：
多组测试数据!!!
对于每组测试数据，第一行一个整数N (N<=10000)，接下来有N-1行，每一行两个数，对于第i行的两个数，它们表示与i号电脑连接的电脑编号以及它们之间网线的长度。网线的总长度不会超过10^9，每个数之间用一个空格隔开。
5
1 1
2 1
3 1
1 1
样例输出:
对于每组测试数据输出N行，第i行表示i号电脑的答案 (1<=i<=N).
3
2
3
4
4
1.先从树中任意顶点进行一遍BFS，距离其最远的顶点便是端点之一，然后再从该端点进行一遍BFS,同样距离其最远的顶点便是另一个端点
2.然后，我们分别以这两个顶点为起点进行一遍BFS,记录下到各点的距离，最后对每个点取到两个端点距离的较大值
1.由于要求所有点到其他点的最长路径长度，可以转换为求树的两个端点到其他所有点的距离，并对每个点的距离取较大值
2.树中最远的两个点之间的距离定义为树的直径，故对应的这两个点被定义为树的端点，且易知端点必然是叶子节点
3.本题利用了链式前向星存边
4.本题为多组数据输入(由于样例只有一组数据加上眼瞎 硬生生多调了一小时bug TAT)
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<string.h>
#define MAXN 50010
struct edge
{
int u,v,w,nxt;
}E[MAXN];
int h[MAXN],tnt,p1,p2,vis[MAXN],dis[MAXN];
int n;
int ans[2][MAXN];
using namespace std;
void add(int u,int v,int w)//前向星
{
E[++tnt].u=u;
E[tnt].v=v;
E[tnt].w=w;
E[tnt].nxt=h[u];
h[u]=tnt;
}
void bfs(int s,int flag)
{
memset(vis,0,sizeof(vis));
memset(dis,0,sizeof(dis));
int maxl=0;
queue<int> q;
q.push(s);
vis[s]=true;
while(!q.empty())
{
int now=q.front();q.pop();
for(int i=h[now];i!=-1;i=E[i].nxt)
{
int to=E[i].v;
if(!vis[to])
{
dis[to]=dis[now]+E[i].w;
if(dis[to]>maxl)
{
maxl=dis[to];
flag==1?p1=to:p2=to;//分别找两个端点
}
vis[to]=1;
q.push(to);
}
}
}
}
void find_duandian()
{
bfs(1,1);
bfs(p1,2);
}
void find_length(int s,int flag)
{
memset(vis,0,sizeof(vis));
queue<int> q;
q.push(s);
vis[s]=true;
while(!q.empty())
{
int now=q.front();q.pop();
for(int i=h[now];i!=-1;i=E[i].nxt)
{
int to=E[i].v;
if(!vis[to])
{
ans[flag][to]=ans[flag][now]+E[i].w;
vis[to]=1;
q.push(to);
}
}
}
}
int main()
{
while(cin>>n)
{
memset(ans,0,sizeof(ans));
tnt=0;p1=0;p2=0;
int u,v,w;
for(int i=1;i<=n;i++) h[i]=-1;
for(int i=2;i<=n;i++)
{
cin>>v>>w;
add(i,v,w);
add(v,i,w);
}
find_duandian();
find_length(p1,0);find_length(p2,1);
for(int i=1;i<=n;i++)
cout<<max(ans[0][i],ans[1][i])<<endl;
}
return 0;
}
新型冠状病毒肺炎（Corona Virus Disease 2019，COVID-19），简称“新冠肺炎”，是指2019新型冠状病毒感染导致的肺炎。
如果一个感染者走入一个群体，那么这个群体需要被隔离！
小A同学被确诊为新冠感染，并且没有戴口罩！！！！！！
危！！！
时间紧迫！！！！
需要尽快找到所有和小A同学直接或者间接接触过的同学，将他们隔离，防止更大范围的扩散。
众所周知，学生的交际可能是分小团体的，一位学生可能同时参与多个小团体内。
请你编写程序解决！戴口罩！！
样例输入：
多组数据，对于每组测试数据：
第一行为两个整数n和m（n = m = 0表示输入结束，不需要处理），n是学生的数量，m是学生群体的数量。0 < n <= 3e4 ， 0 <= m <= 5e2
学生编号为0~n-1
小A编号为0
随后，m行，每行有一个整数num即小团体人员数量。随后有num个整数代表这个小团体的学生。
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
样例输出：
输出要隔离的人数，每组数据的答案输出占一行
4
1
1
1.初始时，每个人只属于自己的小团体，且小团体的成员数目都为1
2.边输入边处理，对于在同一小集体内的两同学，合并他们的小团体，注意改变成员数量
3.最后输出0号学生小A所属小团体的成员数量
1.本题利用了并查集的路径压缩优化
2.只看代码的话是一道裸的并查集的题,但其实可能并不那么好想到，在合并时，所有在同一小集体的学生属于一个并查集很易知，但是如果两个小团体同时具有某个学生，那么这两个小团体其实就同属于一个并查集了（通过该学生建立了联系）
3.故我们只需要进行正常的合并，随后输出0号学生小A所属的并查集的成员个数
(在合并时 如果两学生已经同属于一个并查集了 就要及时return 不然会出错 TAT）
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<string.h>
#define MAXN 50010
int f[MAXN],m,n,tnt[MAXN];
using namespace std;
int find(int x)
{
return x==f[x]? x :f[x]=find(f[x]);
}
void merge(int x,int y)
{
int fx=find(x),fy=find(y);
f[fx]=fy;//fy合并到fx上
if(fx==fy) return;//由于没加这一句话，又de了一年的bug
tnt[fy]+=tnt[fx];
}
int main()
{
while(true)
{
cin>>n>>m;
if(n==0&&m==0) break;
for(int i=0;i<n;i++) { f[i]=i;tnt[i]=1;}
while(m--)
{
int sum;
cin>>sum;
int last=-1,p;
while(sum--)
{
cin>>p;
if(last!=-1) merge(last,p);
last=p;
}
}
cout<<tnt[find(0)]<<endl;
}
system("pause");
return 0;
}
有n块田，需要把这些田全部浇水，可以消耗一定的费用直接在某块田浇水（消耗费用为Wi),也可以消耗一定费用，将水从一块田引到另一块田
求全部灌水的最小消耗
样例输入：
第1行：一个数n
第2行到第n+1行：数wi
第n+2行到第2n+1行：矩阵即pij矩阵
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
样例输出:
一个数字，表示全部灌水的最小消耗
9
1.将n个消耗Wi当做是0号点与i号点之间路径的费用，加入n条边
2.读入1~n号节点之间的费用(采用存边的存储方式)
3.跑一遍Kruskal，求得答案
1.如果没有可以引水的条件，本题本身就是一个最小生成树问题
2.但由于最初的水源是从天上来的，故我们可以将天上也当做一个点，因为最终的生成树中也包含它，且该点到其他点的距离（费用）即为Wi
3.故我们先采用2的思想将图重构，再对这n+1个点跑一边最小生成树，再输出总费用即可
(要注意重构后已经变成n+1个点了，故需要n条边)
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<string.h>
#define MAXN 90010
int n,tnt,ans,sum;
int f[310];
using namespace std;
struct edge
{
int u,v,w;
bool operator < (const edge& x) const{
return w<x.w;
}
}E[MAXN];
int find(int x)
{
return x==f[x]? x : f[x]=find(f[x]);
}
void unite(int x,int y)
{
x=find(x);y=find(y);
f[x]=y;
}
int main()
{
cin>>n;
int w;
for(int i=0;i<=n;i++) f[i]=i;
for(int i=1;i<=n;i++)//引黄河之水
{
cin>>w;
E[++tnt].u=0;
E[tnt].v=i;
E[tnt].w=w;
}
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
cin>>w;
if(i==j) continue;
E[++tnt].u=i;
E[tnt].v=j;
E[tnt].w=w;
}
sort(E+1,E+tnt+1);
for(int i=1;i<=tnt;i++)
{
int x=find(E[i].u),y=find(E[i].v);
if(x==y) continue;
unite(x,y);
sum+=E[i].w;
ans++;
if(ans==n) break;
}
cout<<sum<<endl;
return 0;
}
样例输入：
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2
样例输出:
4
思路很简单，就是构造最小生成树
(但是这个磨人的题干让人难以想到这就是个很简单的最小生成树…)
1.根据题意，我们需要构造出一棵生成树，且该树中的最大权值最小
2.根据常识可知(雾),最小生成树即为最小瓶颈生成树，所以我们只需要构造一棵最小生成树，再从中找到权值最大的边并输出其权值
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<queue>
#include<string.h>
#define MAXN 100010
int n,sum,m,r;
int f[MAXN];
using namespace std;
struct edge
{
int u,v,w;
bool operator < (const edge& x) const{
return w<x.w;
}
}E[MAXN];
int find(int x)
{
return x==f[x]? x : f[x]=find(f[x]);
}
void unite(int x,int y)
{
x=find(x);y=find(y);
f[x]=y;
}
int main()
{
cin>>n>>m>>r;
int u,v,w;
for(int i=1;i<=n;i++) f[i]=i;
for(int i=1;i<=m;i++)
{
cin>>u>>v>>w;
E[i].u=u;
E[i].v=v;
E[i].w=w;
}
sort(E+1,E+m+1);
for(int i=1;i<=m;i++)
{
int x=find(E[i].u),y=find(E[i].v);
if(x==y) continue;
unite(x,y);
sum++;
if(sum==n-1) {cout<<E[i].w<<endl;break;}
}
return 0;
}