week6 作业

A题

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

思路：
首先根据一个起点来判断与这个起点最远的那个端点。然后再根据最远的端点求出另一个端点，即可得到此树的直径，然后从两个端点出发，遍历树中的每个节点，我用的是两个节点，一个用来辨识自己与自己当前距离端点的距离，另一个节点表示的是与此节点相连的节点，而且表示出他们的距离，然后利用队列进行bfs遍历即可，可用visit数组进行剪枝，但切记每轮bfs过后都要清0.
代码：

#include<iostream>
#include<list>
#include<queue>
#include<string.h>
using namespace std;
struct node
{
	int v,w;//与其相连的点，之间的weight。已有的距离。 
	node(int tv,int tw)
	{
		v=tv;
		w=tw;
	}
	node(){
	}
};
struct nod
{
	int v,d;
	nod(int tv,int td)
	{
		v=tv;
		d=td;
	}
	nod()
	{
	}
};
list<node> a[10010];
int vis[10010];
int dis[10010];
int n,v,p,q;
int w;
nod ans(1,0);
nod bfs(nod x)
{
	queue<nod> q;
	q.push(x);
	vis[x.v]=1;
	nod now;
	list<node>::iterator it;
	while(!q.empty())
	{
		now=q.front();q.pop();
		//cout << now.v << endl;
		it=a[now.v].begin();
		
		while(it!=a[now.v].end())
		{
			if(!vis[(*it).v])
			{
				//cout << (*it).v <<endl;
				q.push(nod((*it).v,now.d+(*it).w));
				vis[(*it).v]=1;
				if(ans.d<now.d+(*it).w)
				{
					ans.d=now.d+(*it).w;
					ans.v=(*it).v;
				}
			}
			++it;
		}
	}
	return ans;
}//每个节点多一个表示距离的变量。
void bfss(int g)
{
	queue<nod> q;
	q.push(nod(g,0));
	vis[g]=1;
	nod now;
	list<node>::iterator it;
	while(!q.empty())
	{
		now=q.front();q.pop();
		it=a[now.v].begin();
		while(it!=a[now.v].end())
		{
			if(!vis[(*it).v])
			{
				q.push(nod((*it).v,now.d+(*it).w));
				if(dis[(*it).v]<now.d+(*it).w)
				dis[(*it).v]=now.d+(*it).w;
				vis[(*it).v]=1;
			}
			++it;
		}
	}
 } 
int main()
{
	while(scanf("%d",&n)!=EOF)
	{
		for(int i=0;i<10010;i++)
		a[i].clear();
		memset(vis,0,sizeof(vis));
	memset(dis,0,sizeof(dis));
	for(int i=2;i<=n;i++)
	{
		cin >> v >> w;
		a[i].push_back(node(v,w));
		a[v].push_back(node(i,w));
	}
	nod an(1,0);
	ans.d=0;
	ans.v=1;
	p=bfs(an).v;
	memset(vis,0,sizeof(vis));
	ans.d=0;
	ans.v=1;
	q=bfs(nod(p,0)).v;
	//cout << p << " " << q << endl;
	memset(vis,0,sizeof(vis));
	bfss(p);
	memset(vis,0,sizeof(vis));
	bfss(q);
	for(int i=1;i<=n;i++)
	{
		cout << dis[i] << endl;
	}
	}
	
}

B题

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

思路：
根据所给的数据进行并查集的整合，需要注意的是，多了一个rnk数组，赋初值1，用来记录每个集合包含的元素个数，最后通过find函数先找到根节点，然后再找到这个集合会包括多少个元素。即为最终答案。
代码：

#include<iostream>
using namespace std;
int p[30010];
int rnk[30010];
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;
	p[x]=y;
	rnk[y]+=rnk[x];
	return true;
}
int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m)!=EOF&&!(n==0&&m==0))
	{
		for(int i=0;i<n;i++)
		{p[i]=i;rnk[i]=1;
		}
		while(m--)
		{
			int num,last=-1;
			cin >> num;
			while(num--)
			{
				int p;cin >> p;
				if(last!=-1)
				unite(p,last);
				last=p;
			}
		}
		cout << rnk[find(0)] << endl;
	}
}

C题与D题

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 0
Output
9

思路：
已知每块田既可以灌溉，又可以建立联系，则通过加一个原点，使其与所有点都连通，然后找到最小生成树即可，kruskal算法思想即为依次将边权最小的边依次加入树中，并且不能构成圈，这局要用到并查集算法，然后每加入一次边，就权值累计起来，最终即为要求结果。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
const int maxn = 3e2+10;
using namespace std;
int p[310];
int tot;
int n;
void init(int n){for(int i = 0;i<=n;i++) p[i] = i;}
struct Edge{
	int u,v,w;
	bool operator<(const Edge& a) const 
	{
		return w < a.w;
	}
}Es[maxn*maxn];
int find(int x)
{
	return p[x]==x?x:find(p[x]);
}
bool unite(int x,int y)
{
	x=find(x),y=find(y);
	if(x==y) return false;
	p[x]=y;
	return true;
}
int kruskal()
{
	init(n);
	sort(Es,Es+tot);
	int cnt=0,ans=0;
	for(int i=0;i<tot;i++)
	{
		if(unite(Es[i].u,Es[i].v))
		{
			ans+=Es[i].w;
			if(++cnt==n) return ans;
		}
	}
	return -1;
}//最小生成树,加入最小边权，利用并查集判断是否构成圈。 
int main()
{
	cin >> n;
	tot=0;
	for(int i=1;i<=n;i++)
	{
		cin >> Es[tot].w;
		Es[tot].u=0,Es[tot].v=i,tot++;//0作为原点。 
	}
	for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=n;j++)
			{
				cin >> Es[tot].w;
				if(i!=j)
				{Es[tot].u=i,Es[tot].v=j,tot++;
				}
			}
		}
	printf("%d",kruskal());
	return 0;
}

D：
csp2018124

思路：
与C题大同小异，目的是在所有生成树中，其最大的边权要最小，其实就是最小生成树，依次取出最小的权值，在判断是否构成圈时，注意rnk数组的妙用，我们可以将高度小的根节点挂在高度高的根节点，虽然unite并没有优化，但find函数会更加快的找的自己的跟根节点，然后取出边权最大值，最后输出即可。

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
struct edge
{
	int u,v,w;
	bool operator<(const edge &a) const
	{
		return w<a.w;
	}
}e[100010];
int n,m,res;
int p[50010];
int rnk[50010];
void init(int n)
{
	for(int i=1;i<=m;i++)
	p[i]=i;
}
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(rnk[x]<rnk[y])	
	{p[x]=y;rnk[y]+=rnk[x];
	}
	else
	{p[y]=x;rnk[x]+=rnk[y];
	}
	return true;
}
int kruskal()
{
	sort(e+1,e+1+m);
	int cnt=0,ans=0;
	for(int i=1;i<=m;i++)
	{
		if(unite(e[i].u,e[i].v))
		{
			ans=max(ans,e[i].w);
			if(++cnt==n-1) break;
		}
	}
	return cnt==n-1?ans:-1;
}
int main()
{
	memset(rnk,0,sizeof(rnk));
	cin >> n >> m >> res;
	init(n);
	for(int i=1;i<=m;i++)
	cin >> e[i].u >> e[i].v >> e[i].w;
	cout << kruskal() << endl;
	return 0;
}