week6-作业

最新推荐文章于 2020-04-02 17:44:29 发布

Rainbow-c

最新推荐文章于 2020-04-02 17:44:29 发布

阅读量254

点赞数

分类专栏：程序设计

本文链接：https://blog.csdn.net/qq_43746837/article/details/105199824

版权

程序设计专栏收录该内容

43 篇文章 0 订阅

订阅专栏

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：

Sample Output：

题目分析：

首先回忆一下求树的直径的方法，假设树的最长路的两个叶子节点为v1,v2，从任意一点u出发走到的最远的点一定是（v1,v2）中的一点，然后再从v1或者v2出发走到的最远点一定是v2或者v1。由此经过两次遍历就能找到最长路径。

•这道题不是找最长路径，而是找某个节点x所能到达的最长路径，这并不好直接求出，所以反过来思考，首先这个节点x的最长路径要么是到v1的路径，要么就是到v2的路径。由于不知道往哪边走才是最长的路径，所以需要分别从v1,v2点再次遍历
共需要三次遍历。从两个端点分别求出到该点的距离，找出较大者，即为该点所能到达的最长路径。
利用C++中的STL容器vector记录每一个点的邻接点以及与其相连的边，以及该边的网线长度， vector c[N] ，c[u]表示u点的邻接点数，因为两边是可以互相传送的，所以以无向图的形式存储。在bfs中从某个点宽度搜索所能到达的最远的点，并赋值为point，同时记录下从该点到最远点point的路径长度。三次调用bfs，第一次找到一个最远的端点；第二次从这个最远的端点宽度搜索到另一个最远的端点，并记录从这个最远点端点到所有点的路径长度；第三次从另一个最远的端点进行搜索，记录所有点到这另一个端点的路径长度，比较从两个端点出发的各点路径长度，较大者输出即可。

提交的时候发现这样的写法会导致wronganswer，貌似是因为这种写法是c++11支持的，
在图一这里插入图片描述
改成下面这种形式才能过

代码：

#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;
const int maxn = 2e4 + 5;
struct edge
{
	//int u;
	int v;
	int len;
	edge(int v1,int len1)
	{
		v=v1;
		len=len1;
	}
};
vector<edge> c[maxn];
bool vis[maxn];
void addedge(int u, int v, int len)//添加边 
{
	c[u].push_back(edge(v,len));
	c[v].push_back(edge(u,len));
}
int point;
void bfs(int u, int length[])
{
	queue<int> q;
	memset(vis, false, sizeof(vis));
	point = u;
	int maxx = 0;
	q.push(u);
	vis[u] = true;
	while (!q.empty())
	{
		int temp = q.front();
		q.pop();
		int index = c[temp].size();
		for (int i = 0; i < index; i++)
		{
			if (!vis[c[temp][i].v])
			{
				q.push(c[temp][i].v);
				length[c[temp][i].v] = length[temp] + c[temp][i].len;
				vis[c[temp][i].v] = true;
				if (maxx < length[c[temp][i].v])
				{
					maxx = length[c[temp][i].v];
					point = c[temp][i].v;
				}
			}
		}
	}
}

int main()
{
	int N;
	while (cin>>N)
	{
		memset(c,0,sizeof(c));
		for (int i = 2; i <= N; i++)
		{
			int a, b;//与i号电脑连接的电脑编号以及它们之间网线的长度
			cin >> a >> b;
			addedge(i, a, b);
		}

		int *length = new int[N+1];
		int *length2= new int[N+1];
		for (int i = 1; i <= N; i++)
		{
			length[i] = 0;
		}
		bfs(1, length);//找到一个端点

		for (int i = 1; i <= N; i++)
		{
			length[i] = 0;
			length2[i] = 0;
		}
		int point1 = point;
		bfs(point1, length);//找到另一个端点 

		int point2 = point;
		bfs(point2, length2);

		for (int i = 1; i <= N; i++)
		{
			cout << max(length[i], length2[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

题目分析：

该题题意为找到小A以及和小A有直接或间接接触的所有人，所以用到并查集，对所有人进行遍历，调用并查集合并函数unite，对属于同一集合的元素进行合并，也即将所有和小A有直接或间接接触的人合并为一个群体，最后返回群体数量find(rnk[0])即可。

代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
const int maxn=3e4+10;
int par[maxn],rnk[maxn];
int find(int x)//查找 
{
	return par[x]==x ? x: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;
	rnk[y]+=rnk[x];
	return true;
}
int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m)!=EOF)//n是学生的数量，m是学生群体的数
	{
		if(n==0&&m==0)
		{
			return 0;
		}	
		for(int i=0;i<n;i++)
		{
			par[i]=i;
			rnk[i]=1;
		}
		for(int i=0;i<m;i++)
		{
			int num;//团体人员数量
			int pre=-1;
			scanf("%d",&num);
			for(int i=0;i<num;i++)
			{
				int id;//这个小团体的学生
				scanf("%d",&id);
				if(pre!=-1)
				{
					unite(id,pre); 
				}
				pre=id;	
			}
			
		}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：

题目分析：

如果没有把“黄河之水天上来”删掉，那么就是一个最小生成树问题，所以考虑图重构：加一个超级源点0 号，并向n 个点连边为Wi，然后对这 n+1 个点跑最小生成树即可。

用一个数组e来存储所有的边信息，加上超级源点之后，就形成了n+1个点的图结构，边权为wi或者pij，利用kruskal最小生成树的思想及算法，每次选择一条权值最小的不会形成环的边，加入边集，直到边覆盖完n+1个点，在这里，判断不会形成环的方法采用并查集，当该边加入不会形成环时，将其加入，累计消耗，并实时记录当前已选边数，当选择边数到达n时，选择完毕。输出最终消耗值即为最小消耗值。（注意pii=0，在图结构对于这些边要跳过不存储）

代码：

#include<iostream>
#include<stdio.h>
#include<algorithm> 
using namespace std;
const int maxn=3e2+10;
struct edge
{
	int u;
	int v;
	int w; 
	bool operator<(const edge &p)const//按照权值从小到大排序 
	{
		return w<p.w;
	}
}e[maxn*maxn];

int par[maxn];	
int n,k;
int find(int x)//查找 
{
	return par[x]==x ? x: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()//最小生成树 
{
	for(int i=0;i<n+1;i++)
	{
		par[i]=i;
	}
	sort(e,e+k);//排序
	int ans=0;
	int count=0;
	for(int i=0;i<k;i++)
	{
		if(unite(e[i].u,e[i].v))//该边不构成环可以加入
		{
			ans+=e[i].w;
			count++;//记录已选边的个数 
		} 
		if(count==n)
		{
			return ans;
		} 	
	} 
	return ans;
	
}
int main()
{
	scanf("%d",&n);
	k=0;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&e[k].w);
		e[k].u=0;//超级原点
		e[k].v=i;
		k++; 
	}
	
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			scanf("%d",&e[k].w);
			if(i==j) continue;//pii=0 
			e[k].u=i;
			e[k].v=j;
			k++;
		}
	}
	int temp=kruskal();
	printf("%d",temp);
	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

题目分析：

该题要使得每个节点选择一条路径将数据传输到root，且要求出最优的树结构流水线耗时。即“求解一颗生成树，使得最大边权最小！”

谈及最大值最小，很容易想到二分，二分答案ans，问题转化为原图中不大于ans的边能否使原图联通，二分答案复杂度O(logK)，判断连通性复杂度O(N+M) ，总复杂度O((N+M)logK)。
但是这里也可以不用二分，而是采用最小瓶颈生成树，利用性质：最小生成树一定是瓶颈生成树，求MST 输出最大的边。对所有的边先按边权进行从小到大的排序，再利用kruskal最下生成树算法，依次选择边权最小的边，并实时更新ans=max(ans,e[i].t);当选择边到达n-1的时候选择完毕，输出最终ans即为最小的最大边权。

（注意并查集的时候，一定要进行路径压缩，即return par[x]==x? x:par[x]=find(par[x]);否则提交会报Time limit exceeded on test 101！！）

代码：

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=100010;
struct edge
{
	int u;
	int v;
	int t;
	bool operator<(const edge &p)const
	{
		return t<p.t;
	} 
}e[maxn];
int par[maxn];
int find(int x)//查找
{
	return par[x]==x? x: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 n,m;//n，m分别为点数和边数 
int kruskal()
{
	sort(e+1,e+1+m);
	for(int i=1;i<=n;i++)
	{
		par[i]=i;
	}
	int ans=0;
	int count=0;
	for(int i=1;i<=m;i++)
	{
		if(unite(e[i].u,e[i].v))//该边加入不构成环，可以加入 
		{
			ans=max(ans,e[i].t);
			count++;
		}
		if(count==n-1)
		{
			return ans;
		}
	}
	return ans;
}
int main()
{
	int root;
	cin>>n>>m>>root; 
	for(int i=1;i<=m;i++)
	{
		cin>>e[i].u>>e[i].v>>e[i].t;	
	} 
	int temp=kruskal();
	cout<<temp<<endl; 
	return 0;
}

Rainbow-c

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
week6-作业

A-氪金带东题目：实验室里原先有一台电脑(编号为1)，最近氪金带师咕咕东又为实验室购置了N-1台电脑，编号为2到N。每台电脑都用网线连接到一台先前安装的电脑上。但是咕咕东担心网速太慢，他希望知道第i台电脑到其他电脑的最大网线长度，但是可怜的咕咕东在不久前刚刚遭受了宇宙射线的降智打击，请你帮帮他。提示: 样例输入对应这个图，从这个图中你可以看出，距离1号电脑最远的电脑是4号电脑，他们之间的距...
复制链接

扫一扫