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
思路做法:
关于树的直径问题,首先任选一点开始便历整棵树,找到距离最远的叶结点1,再从叶结点1开始便历整棵树,并记录下每个节点到它的距离,找到最远的另一个叶结点2,与上一次便历相同,从叶结点2出发便历并记录距离,比较每个节点到2个最远叶结点的距离,输出其中的最大值,共便历3次。
总结:
尽管样例只有一组,但要注意题目中说明了有多组输入,因此还要每次都初始化一下各数组,还有一点是注意数据范围。
代码:
#include <stdio.h>
#include <vector>
using namespace std;
const int N = 1e4+10;
struct Edge{
int u, v;
long long w;
Edge(){}
Edge(int _u, int _v, long long _w):u(_u), v(_v), w(_w){}
};
vector<Edge> E[N];
long long vis[N], length, lens[N];
int leaf[3], index; //2个叶子的索引
void addEdge(int u, int v, long long w){
E[u].push_back(Edge(u, v, w));
E[v].push_back(Edge(v, u, w));
}
void dfs(int u, long long len){
if(len > length){
length = len;
leaf[index] = u; //跟新最远叶结点
}
for(int i = 0, n = E[u].size(); i < n; ++i){
if(vis[E[u][i].v] == -1){
vis[E[u][i].v] = len + E[u][i].w;
dfs(E[u][i].v, len + E[u][i].w);
}
}
}
int main(){
int n;
while(~scanf("%d", &n)){
for(int i = 0; i < N; ++i){
while(!E[i].empty()) E[i].pop_back();
}
for(int i = 2; i < n + 1; ++i){
int v; long long w;
scanf("%d %lld",&v, &w);
addEdge(i, v, w);
}
for(int i = 1; i <= n; ++i) vis[i] = -1;
index = 0; length = 0;
vis[2] = 0; dfs(2, 0); //找离u最远的叶子结点
for(int i = 1; i <= n; ++i) vis[i] = -1;
index = 1; length = 0;
vis[leaf[0]] = 0; dfs(leaf[0], 0);
for(int i = 1; i <= n; ++i){
lens[i] = vis[i];
vis[i] = -1;
}
index = 2; length = 0;
vis[leaf[1]] = 0; dfs(leaf[1], 0);
for(int i = 1; i <= n; ++i){
// printf("%d %d\n", vis[i], lens[i]);
printf("%lld\n", vis[i] > lens[i] ? vis[i] : lens[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 0
Sample Output
4
1
1
思路做法:
并查集问题,用树形结构来记录解决。并查集初始化初始stu[i] = i,每个节点自成一家。find操作运用递归查找,最后找到后更新stu[x]以缩短路径,节省时间。unite操作中,返回false因为x,y本就属于同一集合,否则,根据小集合并入到大集合的准则合并,返回true。随着合并操作,最后便历所有节点,与小A所在一个并查集的都记录下来。
总结:
注意find最后的更新操作,否则可能超时。
代码:
#include <stdio.h>
const int N = 3e4 + 5;
int stu[N], rank[N];
int find(int x){ return stu[x] == x ? x : stu[x] = find(stu[x]); }
bool unite(int x, int y){
x = find(x); y = find(y);
if(x == y) return false;
if(rank[x] > rank[y]){
stu[y] = x; rank[x] = (rank[y] += rank[x]);
}else{
stu[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){
stu[i] = i; rank[i] = 1;
}
int num, index0, index, ans = 0;
for(int i = 0; i < m; ++i){
scanf("%d %d", &num, &index0);
for(int j = 1; j < num; ++j){
scanf("%d", &index);
unite(index0, index);
}
}
for(int i = 0; i < n; ++i){
if(find(i) == find(0)) ans++;
}
printf("%d\n", ans);
}
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值
Sample Input
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
Sample Output
9
思路做法:
最小生成树问题的变种。将黄河之水天上来从看做编号为0的农田引水,相应的 W i W_i Wi变为了 P 0 i P_{0i} P0i,在这上面跑最小生成树算法即可。
总结:
用到了并查集来检验是否成环,在最后的循环中用num来检查是否选出了足够的边,可以提前终止循环。另外按照题目的意思,代码中可以加入检查 P 0 i P_{0i} P0i是否用了,即最开始的水是哪来的。
代码:
#include <stdio.h>
#include <algorithm>
using namespace std;
const int N = 3e2+5;
struct Edge{
int u, v, w;
bool operator<(const Edge& e) const {
return w < e.w;
}
}edge[N*N];
int t[N], rk[N];
int find(int x){
return t[x] == x ? x : t[x] = find(t[x]);
}
bool unite(int x, int y){
x = find(x); y = find(y);
if(x == y) return false;
if(rk[x] > rk[y]){
t[y] = x; rk[x] = (rk[y] += rk[x]);
}else{
t[x] = y; rk[y] = (rk[x] += rk[y]);
}return true;
}
int main(){
int n, cnt = 0, ans = 0;
scanf("%d", &n);
for(int i = 0; i <= n; ++i){
t[i] = i; rk[i] = 1;
}
for(int i = 1; i <= n; ++i){
int w; scanf("%d", &w);
edge[cnt++] = {0, i, w};
}
for(int i = 1; i <= n; ++i){
for(int j = 1; j <= n; ++j){
int p; scanf("%d", &p);
if(i < j) edge[cnt++] = {i, j, p};
}
}
sort(edge, edge+cnt);
int num = 0; //加入的边数
for(int i = 0; i < cnt; ++i){
if(unite(edge[i].u, edge[i].v)){
ans += edge[i].w;
if(++num == n) break; //共n+1个点
}
}
printf("%d\n", ans);
return 0;
}
D - 数据中心
题意:
Sample Input
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2
Sample Output
4
思路做法:
最小生成树的变种,算法的解不是生成树的总消耗,而是生成树中最大边能取到的最小值,即在最后的循环中,ans = ans > edge[i].t ? ans : edge[i].t,而不是ans += edge[i].t
总结:
仍然可以用num提前结束循环,其他与最小生成树算法相差不多。
代码:
#include <stdio.h>
#include <algorithm>
using namespace std;
const int N = 5e4+5, M = 1e5+5;
struct Edge{
int v, u, t;
bool operator<(const Edge& e) const {
return t < e.t;
}
}edge[M];
int p[N], rk[N];
int find(int x){
return p[x] == x ? x : p[x] = find(p[x]);
}
bool unite(int x, int y){
x = find(x); y = find(y);
if(x == y) return false;
if(rk[x] > rk[y]){
p[y] = x; rk[x] = (rk[y] += rk[x]);
}else{
p[x] = y; rk[y] = (rk[x] += rk[y]);
}return true;
}
int main(){
int n, m, root, num = 0, ans = 0;
scanf("%d %d %d", &n, &m, &root);
for(int i = 1; i <= n; ++i){
p[i] = i; rk[i] = 1;
}
for(int i = 0; i < m; ++i)
scanf("%d %d %d", &edge[i].v, &edge[i].u, &edge[i].t);
sort(edge, edge+m);
for(int i = 0; i < m; ++i){
if(unite(edge[i].v, edge[i].u)){
ans = ans > edge[i].t ? ans : edge[i].t;
if(++num == n-1) break;
}
}
printf("%d\n", ans);
return 0;
}