《算法笔记》 第十章 提高篇（4）--- 图算法专题

于 2022-03-27 18:28:45 发布
阅读量332 收藏
点赞数
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z__YYYYY/article/details/123760735
版权

图的存储：
①邻接矩阵
用一个二维数组来存放，不适合存放过多顶点（一般不超过1000）
②邻接表
可以用vector来存放邻接表
vector Adj[N];
在这里插入图片描述
以结构体存储节点

struct Node{
	int v,w;
	Node(int _v,int _w): v(_v),w(_w) { }//h构造函数 
};

Adj[1].push_back(Node(3,4));

图的访问：
DFS+邻接矩阵

#include <iostream>
#include <cstdio>
using namespace std;
int n=0;
int maze[101][101]={0};
bool visited[101]={false};

void DFS(int u)
{
	visited[u]=true;
	cout<<"访问节点"<<u<<endl;
	for(int i=0;i<n;i++)
	{
		if(maze[u][i]!=0&&visited[i]!=true)
		{
			DFS(i);
		}
	}
}

void DFStravel()
{
	for(int i=0;i<n;i++)
	{
		if(visited[i]!=true)
		{
			DFS(i);	
		} 
	}
}

int main() 
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			scanf("%d",&maze[i][j]);
		}
	}
	DFStravel();
	return 0;
}

BFS+邻接矩阵

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
int n=0;
int maze[101][101]={0};
bool visited[101]={false};

void BFS(int t)
{
	queue<int> q;
	q.push(t);
	visited[t]=true;
	while(!q.empty())
	{
		int now=q.front();
		q.pop();
		printf("访问%d节点\n",now);
		for(int i=0;i<n;i++)
		{
			if(maze[t][i]!=0&&visited[i]!=true)
			{
				q.push(i);
				visited[i]=true;
			}
		}
	}
}

void BFStravel()
{
	for(int i=0;i<n;i++)
	{
		if(visited[i]!=true)
		{
			BFS(i);	
		}
	}
}

int main() 
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			scanf("%d",&maze[i][j]);
		}
	}
	BFStravel();
	return 0;
}

迪杰斯特拉算法：

#define MAXV 1000
#define INF 9999
using namespace std;
int n,G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV]={false};

void Dijkstra(int s)
{
	fill(d,d+MAXV,INF);
	d[s]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			if(vis[j]==false&&d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)
		{
			return;
		}
		vis[u]=true;
		for(int v=0;v<n;v++)
		{
			if(vis[v]==false&&G[u][v]!=INF&&d[u]+G[u][v]<d[v])
			{
				d[v]=d[u]+G[u][v];		
			}
		}
	}
}

利用迪杰斯特拉算法求最短路径：

#define MAXV 1000
#define INF 9999
using namespace std;
int n,G[MAXV][MAXV];
int d[MAXV];
int pre[MAXV];
bool vis[MAXV]={false};

void Dijkstra(int s)
{
	fill(d,d+MAXV,INF);
	d[s]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			if(vis[j]==false&&d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)
		{
			return;
		}
		vis[u]=true;
		for(int v=0;v<n;v++)
		{
			if(vis[v]==false&&G[u][v]!=INF&&d[u]+G[u][v]<d[v])
			{
				d[v]=d[u]+G[u][v];	
				pre[v]=u;	
			}
		}
	}
}

void DFS(int s,int v)
{
	if(v==s)
	{
		printf("%d\n",s);
		return;
	}
	DFS(s,pre[v]);
	printf("%d\n",v);
}

考试中更多的会出现另一种情况，即从起点到终点最短距离最小的路不止一条，一般题目会给出一个第二标尺（一般第一标尺是距离，在第一标尺无法判断的情况下（距离相等），依靠第二标志来选择路径），常见的第二标尺有：
①给每条边再增加一个边权（比如说花费），然后要求在最短路径有多条时要求路径上的花费之和最小（如果边权是其他含义，也可以是最大）
多了cost【】【】边权数组，c[]记录最小值边权数组
初始化时，c[s]=0,其余都为INF

#define MAXV 1000
#define INF 9999
using namespace std;
int n,G[MAXV][MAXV],cost[MAXV][MAXV];
int d[MAXV];
int c[MAXV];
bool vis[MAXV]={false};

void Dijkstra(int s)
{
	fill(d,d+MAXV,INF);
	d[s]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			if(vis[j]==false&&d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)
		{
			return;
		}
		vis[u]=true;
		for(int v=0;v<n;v++)
		{
			//c[u]代表从起点s到u最少花费
			//cost[u][v] 代表从u到v的花费（边权） 
			if(vis[v]==false&&G[u][v]!=INF)
			{
				if(d[u]+G[u][v]<d[v])
				{
					d[v]=d[u]+G[u][v];
					c[v]=c[u]+cost[u][v];
				}
				else if(d[u]+G[u][v]==d[v]&&c[u]+cost[u][v]<c[v])
				{
					c[v]=c[u]+cost[u][v];
				}	
			}
		}
	}
}

②给每个点再增加一个点权（例如每个城市能收集到的物资或是该城市所对应字母的字母序），然后在最短路径有多条时要求路径上点权之和最大（如果点权是其他含义，也可以是最小）
多了weight[]点权数组，w[]记录最大值点权数组
初始化时，w[s]=weight[s],其余w[]均为0

#define MAXV 1000
#define INF 9999
using namespace std;
int n,G[MAXV][MAXV],weight[MAXV];
int d[MAXV];
int w[MAXV];
bool vis[MAXV]={false};

void Dijkstra(int s)
{
	fill(d,d+MAXV,INF);
	d[s]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			if(vis[j]==false&&d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)
		{
			return;
		}
		vis[u]=true;
		for(int v=0;v<n;v++)
		{
			//w[u]代表从起点s到u收集最大物资 
			//weight[v] 代表从节点对应的点权 
			if(vis[v]==false&&G[u][v]!=INF)
			{
				if(d[u]+G[u][v]<d[v])
				{
					d[v]=d[u]+G[u][v];
					w[v]=w[u]+weight[v];
				}
				else if(d[u]+G[u][v]==d[v]&&w[u]+weight[v]>w[v])
				{
					w[v]=w[u]+weight[v];
				}	
			}
		}
	}
}

③直接问有多少条最短路径
多了一个num[]数组
初始化时，num[s]=1,其余的num[]都为0

#define MAXV 1000
#define INF 9999
using namespace std;
int n,G[MAXV][MAXV],weight[MAXV];
int d[MAXV];
int num[MAXV]; 
bool vis[MAXV]={false};

void Dijkstra(int s)
{
	fill(d,d+MAXV,INF);
	d[s]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			if(vis[j]==false&&d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)
		{
			return;
		}
		vis[u]=true;
		for(int v=0;v<n;v++)
		{
			//num[u]代表从s到u的最短路径条数 
			if(vis[v]==false&&G[u][v]!=INF)
			{
				if(d[u]+G[u][v]<d[v])
				{
					d[v]=d[u]+G[u][v];
					num[v]=num[u];
				}
				else if(d[u]+G[u][v]==d[v]&&w[u]+weight[v]>w[v])
				{
					num[v]+=num[u];
				}	
			}
		}
	}
}

迪杰斯特拉算法和DFS结合求解
迪杰斯特拉算法只能解决非负权值边的题目，如果出现了负值就需要使用SPFA算法。
弗洛伊德算法，求任意两点之间最短路径长度问题，dis【i】【j】表示顶点i到j的最短距离

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int INF = 100000000;
const int MAXV=200;
int n,m;
int dis[MAXV][MAXV]={INF};

void Floyd()
{
	for(int k=0;k<n;k++)
	{
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<n;j++)
			{
				if(dis[i][k]!=INF&&dis[k][j]!=INF&&dis[i][k]+dis[k][j]<dis[i][j])
				{
					dis[i][j]=dis[i][k]+dis[k][j];
				}
			}
		}
	}
}

int main() 
{
	int u,v,w;
	scanf("%d%d",&n,&m);
	for(int i=0;i<m;i++)
	{
		dis[i][i]=0;
	}
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		dis[u][v]=w;
	}
	Floyd();
	return 0;
}

prim算法

const int MAXV=1000;//最大定点数 
const int INF=10000000;//一个最大值 

int n,G[MAXV][MAXV];
int d[MAXV]={INF};
bool vis[MAXV]={false};

int prim()
{
	d[0]=0;
	int ans=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++)
		{
			if(vis[j]==false&&d[j]<MIN)
			{
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)
		{
			return -1;
		}
		vis[u]=true;
		ans+=d[u];
		for(int v=0;v<n;v++)
		{
			if(vis[v]==false&&G[u][v]<d[v])
			{
				d[v]=G[u][v];
			}
		}
	}
	return ans;
}

kruskal算法利用并查集实现
拓扑排序：
用了邻接链表，还可以用来判断是否有向图有环
如果要求有多个入度为零的点，选择编号最小的点，那么把queue改成priority_queue即可

const int MAXV=1000;//最大定点数 
const int INF=10000000;//一个最大值 

int n,m,inDegree[MAXV];
vector<int> G[MAXV];//采用邻接表 

bool topologicalSort()
{
	int num=0;
	queue<int> q;
	for(int i=0;i<n;i++)
	{
		if(inDegree[i]==0)
		{
			q.push(i);
		}
	}
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=0;i<G[u].size();i++)
		{
			int v=G[u][i];
			inDegree[v]--;
			if(inDegree[v]==0)
			{
				q.push(v);
			}
		} 
		G[u].clear();
		num++;
	}
	if(num==n)
	{
		return true;
	}
	else
	{
		return false;
	}
}

关键路径（动态规划）
若需要求最长路径，则可以将边的所有边权全部乘-1，再利用SPFA算法求最短路径，所得结果取反即可

z_J_YYYYY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值