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

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

  1. 总结
  2. 题目题解

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;
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值