算法学习之路的心得五之图论基础

最新推荐文章于 2022-04-17 20:29:22 发布

Ghillie suit.

最新推荐文章于 2022-04-17 20:29:22 发布

阅读量229

点赞数 1

分类专栏：算法学习之路上的心得总结

本文链接：https://blog.csdn.net/cascacasc/article/details/114418762

版权

算法学习之路上的心得总结专栏收录该内容

5 篇文章 0 订阅

订阅专栏

GDUT 20 寒假集训专题5.图论基础

总结
题目题解

1.图的存储

目前我所知道的图的存储大致有三种，

第一种是用一个二维数组G[n] [m],对应的两个点如果有边就对应的赋值，但是要注意题目所给的是有向还是无向，有时候两个点之间有多重条边，这时候用二维数组来存的图就很高效的更新最短边(最长边)的值。

第二种是用stl里面的vector，设置一个v[n],来存图，用这个来存的优点是高效利用空间，还有后期搜索所有边也方便，

第三种是适合边中有多个条件，比如一条路里面有经过所需的时间，还有过路费，这时候用上述两种就很难实现了(其实用vector也可以存结构体，但是搜索边的时候效率反而不高，可能会超时)。这种方法用一个结构体数组node[n]+一个数组来实现，具体参考以下代码，（看不懂的可以写写，模拟一下数组来存几个数应该可以看懂了qwq）

struct node {  //结点
	int u,l,t; //各种题目所需的值
	int next;  //下一条边
}G[10010];
int len;
int first[105]; //用来存每个点的最后一条边的结点，然后通过结点里面的next，又可以访问下一条边
void set(int e,int u,int l,int t)  //存放边
{
		G[len].u=u;
		G[len].l=l;
		G[len].t=t;
		G[len].next=first[e];
		first[e]=len++;
}
for(int i=first[u];i!=-1;i=G[i].next) //这样来遍历每一条边

2.prim算法

图论里面求最小生成树的一个很经典的算法，大概就是从一个根节点出发，不断的更新周边点的值，直到所有点都被确定下来，把d数组里面的所有结点的值加起来就是最小生成树的值了。

以下是 ‘ 伪 ’ 模板

#include <list>
#include <iostream>
using namespace std;
int INT=2000000000;
int G[105][105],color[105],d[105],p[105],n;//G存图，color存结点状态，d存最小值，p存树
void prim(void )
{
		d[1]=0;
		p[1]=-1;
		while(1){
			int minv=INT,v;
			for(int i=1;i<=n;i++){
				if(color[i]==1&&d[i]<minv){
					v=i;
					minv=d[i];
				}
			}
			if(minv==INT){
				break;
			}
			color[v]=0;
			for(int i=1;i<=n;i++){
				if(color[i]==1&&G[v][i]>=0){
					if(G[v][i]<d[i]){
						d[i]=G[v][i];  
						p[i]=v;
					}
				}
			}
		}
		
}
int main()
{
		cin>>n;
		for(int i=1;i<=n;i++){
			d[i]=INT;
			color[i]=1;
			for(int j=1;j<=n;j++){
				cin>>G[i][j];
			}
		}
		prim();
		int ans=0;
		for(int i=1;i<=n;i++){
			ans+=d[i];
		}
		cout<<ans<<endl;
		return 0;
}

3.迪克斯特拉算法

这个迪克斯特拉算法是用来算单源最短路径，说白了就是一个点到其他所有点的最短路径，如果题目难一点，就要用优先队列来优化这个算法，下面也算是一个 ‘ 伪 ’ 模板了。这里有一个巧妙的地方就是，我们本来要求最小值的，而优先队列是top最大值的，这时候只需要乘了一个-1就行了。这个算法只能说dddd

#include <vector>
#include <list>
#include <queue>
#include <iostream>
using namespace std;

int INT=2000000000;
int color[10005],d[10005],n;
vector <pair<int ,int > > V[10005];
void di(void )
{
		priority_queue <pair<int ,int > > pq;
		pair<int ,int > p;
		for(int i=0;i<n;i++){
			color[i]=1;
			d[i]=INT;
		}
		d[0]=0;
		p.first =0;
		p.second =0;
		pq.push(p);
		while(!pq.empty()){
			int v,c;
			p=pq.top();
			pq.pop(); 
			color[p.second ]=0;
			if(p.first *(-1)>d[p.second ]){
				continue;
			}
			v=p.second ;
			c=p.first *(-1);
			for(int i=0;i<V[v].size();i++){
				p=V[v][i];
				if(color[p.second ]==1&&d[p.second ]>c+p.first ){
					d[p.second ]=c+p.first ; 
					pq.push(make_pair((-1)*(c+p.first ),p.second ));
				}
			}
		}
		
}
int main()
{
		cin>>n;
		for(int i=0;i<n;i++){
			int u,k;
			cin>>u>>k;
			for(int i=0;i<k;i++){
				int v,c;
				cin>>v>>c;
				V[u].push_back(make_pair(c,v));
			}
		}
		di();
		for(int i=0;i<n;i++){
			cout<<i<<' '<<d[i]<<endl;
		}
		return 0;
}

4.弗洛伊德！！

当然了，这个弗洛伊德不是那个美国黑人，而是求任意两点之间最短距离的弗洛伊德算法。

核心算法很短很短，但是很方便，这个算法也可以灵活运用，用来求两点是否连通，也很方便

for(int k=1;k<=n;k++){
	for(int i=1;i<=n;i++){
        if(G[i][k]==INF)continue;
		for(int j=1;j<=n;j++){
            if(G[k][j]==INF)continue;
			G[i][j]=min(G[i][j],G[i][k]+G[k][j]);
		}
	}
}

5.拓扑排序(bfs)

拓扑排序是用来排序做任务的先后顺序，按照这个顺序来做保证不会出错，当然了，求出来的排序可能只是其中一种，比如说你要炒菜之前肯定要先洗菜的，洗菜之前，肯定要先买菜的。所以用拓扑排序就可以排成买菜 --> 洗菜–> 炒菜。大概就是用来这样的吧。

下面是伪模板。。。

#include <iostream>
#include <list>
#include <queue>
using namespace std;
list <int > out1,out2;
int G[105][105],n;
int du[105],color[105];
void bfs(int u)
{
		queue <int > q;
		q.push(u);
		color[u]=0;
		out1.push_back(u);
		while(!q.empty()){
			u=q.front();q.pop();
			for(int i=1;i<=n;i++){
				if(G[u][i]==0){
					continue;
				}
				du[i]--;
				if(color[i]==1&&du[i]==0){
					q.push(i);
					color[i]=0;
					out1.push_back(i);
				}
			}
		}	
} 
int main()
{
		int m;
		cin>>n>>m;
		for(int i=1;i<=n;i++){
			du[i]=0;
			color[i]=1;
			for(int j=1;j<=n;j++){
				G[i][j]=0;
			}
		}
		for(int i=0;i<m;i++){
			int a,b;
			cin>>a>>b;
			G[b][a]=1;
			du[a]++;
		}
		for(int i=1;i<=n;i++){
			if(color[i]==1&&du[i]==0){
				bfs(i);
			}
		}
		return 0;
}

1.畅通工程再续

题目链接

题目描述：相信大家都听说一个“百岛湖”的地方吧，百岛湖的居民生活在不同的小岛中，当他们想去其他的小岛时都要通过划小船来实现。现在政府决定大力发展百岛湖，发展首先要解决的问题当然是交通问题，政府决定实现百岛湖的全畅通！经过考察小组RPRush对百岛湖的情况充分了解后，决定在符合条件的小岛间建上桥，所谓符合条件，就是2个小岛之间的距离不能小于10米，也不能大于1000米。当然，为了节省资金，只要求实现任意2个小岛之间有路通即可。其中桥的价格为 100元/米。

解题思路：题目大意是给出很多很多坐标点，然后让你用最少的钱连通他们，这个思路其实很明确，是最小生成树的问题！这个题目的难点是边给的不明确，一开始我也没想到怎么把边搞出来，然后就想到了。。。最多100个岛，每两个岛相连，最多也就n(n-1)/2这么多条边，通过坐标来判断每两个岛之前的距离符不符合建桥，如果不符合那就意味着这两个岛没边咯。然后就…套上面的求最小生成树的prim算法就行了。但是这里要特判一下，因为上面那个模板题目保证是有答案的，这个题目就可能没答案，就要遍历一下d[i]的值，如果其中一个等于INT(我定义的无穷大)，这就意味着这个点是个 “ 孤儿 ” 点，那就没答案了，要oh，no了 qwq…

ac代码:

#include <iostream>
#include <cstdio>
using namespace std;
struct node {
	int x,y;
} S[105];
int INT=2000000000;
int n,color[105];
double d[105],G[105][105];
void prim(int u)
{
		while(1){
			double minv=INT;
			int v;
			for(int i=1;i<=n;i++){
				if(color[i]==1&&d[i]<minv){
					v=i;
					minv=d[i];
				}
			}
			if(minv==INT){
				break;
			}
			color[v]=0;
			for(int i=1;i<=n;i++){
				if(G[v][i]==0){
					continue;
				}
				if(color[i]==1&&d[i]>G[v][i]){
					d[i]=G[v][i];
				}
			}
		} 
}
int main()
{
		int t;
		cin>>t;
		while(t--){
			cin>>n;
			for(int i=1;i<=n;i++){
				cin>>S[i].x>>S[i].y;
				color[i]=1;
				d[i]=INT;
				for(int j=1;j<=n;j++){
					G[i][j]=0;
				}
			}
			d[1]=0;
			for(int i=1;i<n;i++){
				for(int j=i+1;j<=n;j++){
					int x1=S[i].x,y1=S[i].y;
					int x2=S[j].x,y2=S[j].y;
					double l;
					l=sqrt(pow(x1-x2,2)+pow(y1-y2,2));
					if(l>=10.0&&l<=1000.0){
						G[i][j]=l;
						G[j][i]=l;
					}
				}
			}
			prim(1);
			double sum=0;
			int t=0;
			for(int i=1;i<=n;i++){
				if(d[i]==INT){
					cout<<"oh!"<<endl;
					t=1;
					break;
				}
				sum+=d[i];
			}
			if(t==0)
			printf("%.1lf\n",sum*100);
		}
		
		return 0;
}

2.Til the Cows Come Home

题目链接

题目描述 : 贝茜在外面的地里，她想回到谷仓尽可能多地睡上一觉，要不就等着农夫约翰早上叫醒她去挤牛奶。贝西需要睡美容觉，所以她想尽快回来。农民约翰的田地有N (2 <= N <= 1000)个地标，唯一编号为1…地标是谷仓;贝西整天站在的苹果园是地标n，奶牛使用T (1 <= T <= 2000)在地标之间不同长度的双向牛道在田野中行进。贝西对自己的导航能力没有信心，所以一旦开始，她总是沿着一条路线从起点一直走到终点。根据地标之间的路径，确定贝茜回到谷仓所需要走的最小距离。保证存在这样的路由。

解题思路:这题就是个单源最短路径问题，说白了就是从1到n点找出最短的路径。这题有点坑(也不算是坑，算是加大难度了吧)，如果用一般的遍历边的方法，会超时！！这里要用优先队列来优化，知道了这个之后， ~~用上面的伪模板搞一下下？？~~

ac代码

#include <iostream>
#include <queue>
using namespace std;
int n;
int INT=2000000000;
int G[2005][2005];
int color[1005];
int d[1005];
void di(int u)
{
		priority_queue <pair<int ,int > > pq;
		pair <int ,int > p;
		p.first=0;
		p.second=u;
		pq.push(p);
		while(!pq.empty()){
			p=pq.top();pq.pop();
			if(d[p.second]<p.first*(-1)){
				continue;
			}
			color[p.second]=0;
			for(int i=1;i<=n;i++){
				if(G[p.second][i]==INT){
					continue;
				}
				if(color[i]==1){
					if(G[p.second][i]+p.first*(-1)<d[i]){
						d[i]=G[p.second][i]+p.first*(-1);
						pq.push(make_pair((-1)*d[i],i));
					}
				}
			}
			
		}
}
int main()
{
		int t;
		cin>>t>>n;
		for(int i=1;i<=n;i++){
			color[i]=1;
			d[i]=INT;
			for(int j=1;j<=n;j++){
				G[i][j]=INT;
			}
		}
		d[1]=0;
		for(int i=0;i<t;i++){
			int a,b,c;
			cin>>a>>b>>c;
			if(G[a][b]>c){
				G[a][b]=c;
				G[b][a]=c;
			}
		}
		di(1);
		cout<<d[n]<<endl;
		return 0;
}

Ghillie suit.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法学习之路的心得五之图论基础

GDUT 20 寒假集训专题5.图论基础总结题目题解1.图的存储目前我所知道的图的存储大致有三种，第一种是用一个二维数组G[n] [m],对应的两个点如果有边就对应的赋值，但是要注意题目所给的是有向还是无向，有时候两个点之间有多重条边，这时候用二维数组来存的图就很高效的更新最短边(最长边)的值。第二种是用stl里面的vector，设置一个v[n],来存图，用这个来存的优点是高效利用空间，还有后期搜索所有边也方便，第三种是适合边中有多个条件，比如一条路里面有经过所需的时间，还有过路费，这时候
复制链接

扫一扫