我的作业之旅之WEEK6作业

A-氪金带东

题干
思路
分析题目，把相连的电脑系统看做一棵树，求每台电脑到其他电脑最远的距离，相当于找到一条该树的最大路径的两个端点，比较每台电脑到两个端点的距离，取最大。所有的电脑一定连接在这条路径上，并且除两端节点，其他的都与中间路径相连并且只连接一条路，否则若与端点相连的话端点就不是端点了。
用三次dfs，第一次从任意一点出发遍历找到第一个距离他最远的一个端点，第二次从第一个端点出发，遍历找到另一个端点，同时用一个数组记录每个节点到第一个端点的距离，最后一次从第二个端点出发遍历到第一个节点，记录每个点到第二个端点的距离。找最远端点时，也是利用每个节点距离出发节点的距离，当距离比目前找到的最远距离大时，更新最远节点（因为不可避免会遇到分岔路口，不确定哪一个选择是最远的）。
在建立树模型时，利用存储边索引的int数组，数组的索引代表的是每个树枝的起点，数组内存储的是以该点为起点的路径的第一条边的索引。由于每条边含next指针，所以可以一直找下一条边，而且由于next可能不止一个，但是上一个只有一个，于是将每个新节点从路径里从后往前插入。
代码

#include<iostream> 
#include<cstring>
#include<cstdio>
#include<queue> 
using namespace std;
struct edge{
	int u,v,w,next;
}edges[20005];//记录每条边的信息，next指向下一条边的坐标 
int n,head[10005];//头结点内存的是边的索引 
int tot=1;//当前头结点边的索引 
int v1=0,v2=0;//两个最长路径的端点 
int a[10005],b[10005],ans;//存储每条边距离最远叶点的的距离 
void chushi()//初始化树 
{
	tot=1;
	for(int i=0;i<=n;i++)
	{
		head[i]=-1;
	}
}
void addedge(int u,int v,int w)//将每条边加入树中 ,对应将边插入入度的节点 
{
	edges[tot].u=u;
	edges[tot].v=v;
	edges[tot].w=w;
	edges[tot].next=head[u];
	head[u]=tot;
	tot++;
}
void dfs(int u)
{
	for(int i=head[u];i!=-1;i=edges[i].next)
	{
		if(a[edges[i].v]==-1)
		{
			a[edges[i].v]=a[edges[i].u]+edges[i].w;
			if(a[edges[i].v]>a[v1])//距离初始节点最远的点才是端点 
			v1=edges[i].v; 
			dfs(edges[i].v);
		}
		
	}
 }
 void dfss(int u)
 {
 	for(int i=head[u];i!=-1;i=edges[i].next)
	{
		if(a[edges[i].v]==-1)
		{
			a[edges[i].v]=a[edges[i].u]+edges[i].w;
			if(a[edges[i].v]>a[v2])//距离初始节点最远的点才是端点 
			v2=edges[i].v; 
			dfss(edges[i].v);
		}
		
	}
  } 
  void dss(int u)
  {
  	for(int i=head[u];i!=-1;i=edges[i].next)
	{
		if(b[edges[i].v]==-1)
		{
			b[edges[i].v]=b[edges[i].u]+edges[i].w;
			dss(edges[i].v);
		}
		
	}
  }
 int main()
 {
 	while(cin>>n)
 	{
 		chushi();
 		int x,y;
 		for(int i=2;i<=n;i++)
 		{
 			scanf("%d %d",&x,&y);
 			addedge(x,i,y);
 			addedge(i,x,y);
		}
		memset(a,-1,sizeof(a));
		a[1]=0;
		dfs(1);
		memset(a,-1,sizeof(a));
		a[v1]=0;
		dfss(v1);
		memset(b,-1,sizeof(b));
		b[v2]=0;
		dss(v2);
		for(int i=1;i<=n;i++)
		{
			ans=max(a[i],b[i]);
			printf("%d\n",ans);
		}
	 }
	 return 0;
  } 

B-戴好口罩

题干
思路
分析题意，隔离人数即为所有被感染学生所在的集合和并集总人数。
利用并查集，在输入每个小团体成员时，将同一个团体的合并为一个集合。若该集合有元素同时在多个集合里，后输入的集合会与前面输入的集合合并。用一个数组存储每个集合的数量（索引为代表元），最后输出索引为find（0）的的数量即为最终需要隔离的人数。
代码

#include<iostream>
using namespace std;
const long long int maxn=3e4+5;
long long int mu[maxn],num[maxn];
long long int n,m;
void chushi()
{
	for(int i=0;i<n;i++)
	{
		mu[i]=i;
		num[i]=1;
	}
}
int find(int x)
{
	if(mu[x]==x)
	return x;
	else
	return find(mu[x]);
}
bool unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return false;
	else
	{
		mu[x]=y;
		num[y]=num[y]+num[x];
		return true;
	}
}
int main()
{
	while(cin>>n>>m)
	{
		if(n==0&&m==0)
		return 0;
		chushi();
		for(int i=0;i<m;i++)
		{
			int a,b,c;
			cin>>a;
			b=-1;
			for(int j=0;j<a;j++)
			{
				cin>>c;
				if(b!=-1)
				unite(c,b);
				b=c;
			}
		}
		printf("%d\n",num[find(0)]);
	}
	return 0;
}

C- 掌握魔法の东东 I

题干

思路
分析题意，将黄河之水天上来理解为银河之水到每块田一条边，加上其余的每两块田之间的边，我们就构建了一个加权无向图。求灌溉的最小消耗就转化为求最小生成树问题。可以用克鲁斯卡尔算法，将所有的边按照权值大小排序，每次取最小的一条边，看是否可以合并到生成树里。
可以用并查集来实现，每取一条边，判断该边两点是否已被合并（若合并，说明取其会成环，弃之），未被合并就给他并进去，将权重累加，最后得到最小生成树（边数为n）。
代码

#include<iostream>
#include<algorithm>
using namespace std;
long long int mu[1000010],num[1000010];
long long int n,ans=0;
void chushi()
{
	for(int i=0;i<=n;i++)
	{
		mu[i]=i;
		num[i]=1;
	}
}
int find(int x)
{
	if(mu[x]==x)
	return x;
	else
	return find(mu[x]);
}
bool unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return false;
	else
	{
		mu[x]=y;
		num[y]=num[y]+num[x];
		return true;
	}
}
struct edge//建立边的结构体 
{
	int u;//一个顶点 
	int v;//两个顶点 
	int weight;//权值 
	edge() {};
	edge(int u, int v, int weight)
	{
		this->u = u;
		this->v = v;
		this->weight = weight;
	}

	bool operator <(edge x)
	{
		return weight<x.weight;
	}
}edges[200010];
long long int index=0;
int main()
{

	cin>>n;
	chushi();	
	int w;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&w);
		edges[index]=edge(0,i,w);
		index++;
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			scanf("%d",&w);
			if(i==j)
			continue;
			edges[index]=edge(i,j,w);
			index++;
		}
	}
	sort(edges,edges+index);
	int a,b;
	for(int i=0;i<index;i++)
	{
		//cout<<edges[i].u<<endl;
		a=edges[i].u;
		b=edges[i].v;
		if(unite(a,b))
		ans=ans+edges[i].weight;
	}
	printf("%lld",ans);
	return 0;
}

D-数据中心

题干
思路
显然，D题跟C题极度类似。并查集+最小生成树。
最小生成树意味着所有的点都相互连通，不管哪个点是root，其他点都与root有通路，并且题目要求的Tmax指的是最小生成树里边的权值最大的那个。当边的个数达到n-1时，说明生成树完成，若是最终边数不能达到n-1，说明无法生成最小生成树。
代码

#include<iostream>
#include<algorithm>
using namespace std;
 int mu[50005];
int n,m,opp,ans=0;
void chushi()
{
	for(int i=0;i<=n;i++)
	{
		mu[i]=i;
	}
}
int find(int x)
{
	return
	mu[x]==x?x:mu[x]=find(mu[x]);
}
bool unite(int x,int y)
{
	x=find(x);
	y=find(y);
	if(x==y)
	return false;
	mu[x]=y;
		return true;
}
struct edge//建立边的结构体 
{
	int u;//一个顶点 
	int v;//两个顶点 
	int weight;//权值 
	bool operator <(edge x)
	{
		return weight<x.weight;
	}
}edges[100005];

int main()
{
	scanf("%d%d%d",&n,&m,&opp);
	chushi();	
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&edges[i].u,&edges[i].v,&edges[i].weight);	
	}
	sort(edges,edges+m);
	int a,b,nn=0;
	for(int i=0;i<m;i++)
	{
		//cout<<edges[i].u<<endl;
		a=edges[i].u;
		b=edges[i].v;
		if(unite(a,b))
		{
				ans=edges[i].weight;
				nn++;
				if(nn==n-1)
				break;						
		}				
	}
	int final;
	final=nn==n-1?ans:-1;
	printf("%d\n",final);
	return 0;
}