图论入门

最新推荐文章于 2023-10-20 21:41:15 发布

spetator

最新推荐文章于 2023-10-20 21:41:15 发布

阅读量294

点赞数

文章标签：算法图论

本文链接：https://blog.csdn.net/spetator/article/details/107215384

版权

这篇博客介绍了图论在数据中心、疾病防控和农田灌溉等场景的应用。通过实例展示了如何利用图论算法，如寻找最远距离、并查集解决实际问题，以及最小生成树在解决网络连接优化中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

图论入门

#A氪金带东
#题目：
实验室里原先有一台电脑(编号为1)，最近氪金带师咕咕东又为实验室购置了N-1台电脑，编号为2到N。每台电脑都用网线连接到一台先前安装的电脑上。但是咕咕东担心网速太慢，他希望知道第i台电脑到其他电脑的最大网线长度，但是可怜的咕咕东在不久前刚刚遭受了宇宙射线的降智打击，请你帮帮他。

提示: 样例输入对应这个图，从这个图中你可以看出，距离1号电脑最远的电脑是4号电脑，他们之间的距离是3。 4号电脑与5号电脑都是距离2号电脑最远的点，故其答案是2。5号电脑距离3号电脑最远，故对于3号电脑来说它的答案是3。同样的我们可以计算出4号电脑和5号电脑的答案是4.

##输入：
输入文件包含多组测试数据。对于每组测试数据，第一行一个整数N (N<=10000)，接下来有N-1行，每一行两个数，对于第i行的两个数，它们表示与i号电脑连接的电脑编号以及它们之间网线的长度。网线的总长度不会超过10^9，每个数之间用一个空格隔开。

##输出：
对于每组测试数据输出N行，第i行表示i号电脑的答案 (1<=i<=N).
#样例输入：
5
1 1
2 1
3 1
1 1
#样例输出：
3
2
3
4
4

图论的入门题目。这题要找的是每个点到图中其他点的最远距离
首先给一个结论（证明挺麻烦的）：一个点在图中的最大距离，一定是到某一个端点的距离。端点则是树的直径的端点。

所以该做的就是：
从任一点开始，dfs找到一个最远的点（这一定是一个端点
从这一点继续开始，dfs找到最远的点（这一定是另外一个端点，同时获得了这点到所有点的距离
从另一个端点开始，dfs再找回来，得到了这点到所有点的距离。
然后取个max就能获得所有点到最远点的距离
所要求的工作就走完了。

当然找距离这件事bfs也可以orz
因为没权值
关于找最远距离那个，可以维护一个最远点标记和最大距离标记，然后dfs过程记录当前距离，然后不断更新

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
struct edge
{
	int point1;
	int value1;
	edge(int _x,int _y)
		:point1(_x),value1(_y)
		{
			
		}
};
vector<vector<edge> > x;
int max(int x,int y)
{
	if(x>y)
		return x;
	else return y;
}
int max_length;
int zuizhang[1000000];
int fathest;
void dfs(int begin,int last,int length)
{
	if(length>max_length)
	{
		max_length=length;
		fathest=begin;
	}
	for(int i=0;i<x[begin].size();i++)
	{
		
		int _value=x[begin][i].value1;
		int _point=x[begin][i].point1;
		if(_point==last) continue;
		dfs(_point,begin,length+_value);
        zuizhang[_point]=max(zuizhang[_point],length+_value);
	}
}
int main()
{
	int n;
	while(cin>>n)
	{
		max_length=0;
		memset(zuizhang,0,sizeof(zuizhang));
		x.clear();
		int n1,m;
		x.resize(n+5);
		for(int i=1;i<n;i++)
		{
			scanf("%d%d",&n1,&m);
			edge x1(n1,m);
			//cout<<"hello";
			x[i+1].push_back(x1);
			//cout<<"hello";
			edge x2(i+1,m);
			x[n1].push_back(x2);
		}
		dfs(1,-1,0);
		dfs(fathest,-1,0);
		dfs(fathest,-1,0);
		for(int i=1;i<=n;i++)
		{
			cout<<zuizhang[i]<<endl;
		}
	}
	return 0;
}

#B戴好口罩
#题目：
新型冠状病毒肺炎（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

相当朴素的并查集问题。并查集也可以理解为等价类。即：两个元素同一类就并进一个集合。
这题就是，接触过就并进一个集合，该集合有病人则视为该集合全是病人。并查集用一个father数组和一个往前找的递归函数实现。（初始化F（i）=i A和B并起来则是F（A）=B 找的时候找到F（i）=i才停止返回，否则进递归）

针对本题，还要记录下每个集合里面元素数量，加一个accest数组

#include<iostream>
using namespace std;
int father[1000000];
int accest[1000000];
int find(int i)
{
	if(father[i]==i)
		return i;
	else return father[i]=find(father[i]);
}
bool unit(int x,int y)
{
	x=find(x);y=find(y);
	if(x==y) return false;
	if(accest[x]>accest[x])	{	accest[x]=(accest[x]+accest[y]); father[y]=x;	}
	else{ accest[y]=(accest[y]+accest[x]); father[x]=y;}
	return true;
}
int main()
{
	int n,m;
	cin>>n>>m;
	while(n!=0||m!=0)
	{
		for(int i=0;i<n;i++)
		{
			accest[i]=1;
			father[i]=i;
		}
		for(int i=0;i<m;i++)
		{
			int k;
			cin>>k;
			int i1,i2;
			cin>>i1;
			for(int j=0;j<k-1;j++)
			{
				scanf("%d",&i2);
				unit(i1,i2);
			}
		}
		cout<<accest[find(0)]<<endl;
		cin>>n>>m;
	}
	
	return 0;
}

#C掌握魔法的东东
#3题目：
东东在老家农村无聊，想种田。农田有 n 块，编号从 1~n。种田要灌氵
众所周知东东是一个魔法师，他可以消耗一定的 MP 在一块田上施展魔法，使得黄河之水天上来。他也可以消耗一定的 MP 在两块田的渠上建立传送门，使得这块田引用那块有水的田的水。 (1<=n<=3e2)
黄河之水天上来的消耗是 Wi，i 是农田编号 (1<=Wi<=1e5)
建立传送门的消耗是 Pij，i、j 是农田编号 (1<= Pij <=1e5, Pij = Pji, Pii =0)
东东为所有的田灌氵的最小消耗

##输入：
第1行：一个数n
第2行到第n+1行：数wi
第n+2行到第2n+1行：矩阵即pij矩阵

##输出：
东东最小消耗的MP值

##样例：

#样例输入：
4
5
4
4
3
0 2 2 2
2 0 3 3
2 3 0 4
2 3 4 0
#样例输出：
9
最小生成树问题，（克鲁斯卡尔算法板子题
可能最想问的就是，天上来的水咋办。。很简单，加一个零号节点，它到各点的距离就是所谓天上来的耗费。
关于克鲁斯卡尔算法
离散数学大家都学过的，不重复不重复（其实就是懒
所需要的并查集知识参考T2.。
克鲁斯卡尔算法步骤
1.把边从小到大排序
2.每次选一个边，如果边的两点不是一个集合，就并到一个集合，否则找下一个边
3.整个图只有一个连通分量的时候停止

优化方法：1.压缩路径就是并查集找根的时候，顺便就把该元素往上一层挂，做到查一次就肯定压缩成两层
2.并的时候大树挂在小树上

#include<iostream>
#include<algorithm>
using namespace std;
int father[1000000];
int accest[1000000];
struct edge
{
	int point1;
	int point2;
	int value1;
	//	int size;
	edge() {
	}
	edge(int _x, int _z, int _y)
		:point1(_x), point2(_z), value1(_y)
	{

	}
};
edge x[10000000];
bool cmp(edge x, edge y)
{
	return x.value1 > y.value1;
}
int find(int i)
{
	if (father[i] == i)
		return i;
	else return father[i] = find(father[i]);
}
bool unit(int x, int y)
{
	x = find(x); y = find(y);
	if (x == y) return false;
	if (accest[x] > accest[x]) { accest[x] = (accest[x] + accest[y]); father[y] = x; }
	else { accest[y] = (accest[y] + accest[x]); father[x] = y; }
	return true;
}
int main()
{

	int n;
	cin >> n;
	for (int i = 0; i <= n; i++)
	{
		father[i] = i;
		accest[i] = 1;
	}
	
	int tx = 0;
	for (int i = 1; i <= n; i++)
	{
		int w;
		cin >> w;
		edge x1(0, i, w);
		x[tx] = x1;
		tx++;
	}
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			int a1;
			cin >> a1;
			if (j > i)
			{

				edge x1(i, j, a1);
				x[tx] = x1;
				tx++;
			}

		}
	}
	int ans = 0;
	sort(x, x + tx, cmp);
	for (int i = tx - 1; i >= 0; i--)
	{
		//cout<<"hello"<<endl;
		if (find(x[i].point1) != find(x[i].point2))
		{
			unit(x[i].point1, x[i].point2);
			ans += x[i].value1;
			//cout<<"hello"<<endl;
		}
	}
	cout << ans << endl;
	return 0;
}

D数据中心

题目：

样例输入
4
5
1
1 2 3
1 3 4
1 4 5
2 3 8
3 4 2
样例输出
4
（就是csp 18-2-4）
题面很长请只关心这个

所以这个题是找，最小生成树最长边。。
比上一题还要像克鲁斯卡尔板子题

#include<iostream>
#include<algorithm>
using namespace std;
int father[1000000];
int accest[1000000];
struct edge
{
	int point1;
	int point2;
	int value1;
	edge() {
	}
	edge(int _x, int _z, int _y)
		:point1(_x), point2(_z), value1(_y)
	{

	}
};
edge x[10000000];
bool cmp(edge x, edge y)
{
	return x.value1 > y.value1;
}
int find(int i)
{
	if (father[i] == i)
		return i;
	else return father[i] = find(father[i]);
}
bool unit(int x, int y)
{
	x = find(x); y = find(y);
	if (x == y) return false;
	if (accest[x] > accest[x]) { accest[x] = (accest[x] + accest[y]); father[y] = x; }
	else { accest[y] = (accest[y] + accest[x]); father[x] = y; }
	return true;
}
int main()
{
	int m;
	cin>>m;
	int max=0;
	int n;
	cin >> n;
	int root;
	cin>>root;
	for (int i = 0; i <= n; i++)
	{
		father[i] = i;
		accest[i] = 1;
	}
	
	int tx = 0;
	int b1,b2,b3;
	for(int i=0;i<n;i++)
	{
		cin>>b1>>b2>>b3;
		edge x1(b1,b2,b3);
		x[tx] = x1;
		tx++;
	}
	int ans = 0;
	sort(x, x + tx, cmp);
	for (int i = tx - 1; i >= 0; i--)
	{
		if (find(x[i].point1) != find(x[i].point2))
		{
			unit(x[i].point1, x[i].point2);
			max=x[i].value1;
		}
	}
	cout << max << endl;
	return 0;
}

改改T3 就是了/（懒