本文是对图论的总结，重点介绍了最短路径算法Floyd、Dijkstra、Bellman-Ford和SPFA，以及最小生成树的Prim和Kruskal算法。此外，还提及了建图方法如边表和邻接矩阵，以及并查集的基本概念。
图论总结
图论定义：图G=（V,E）是一个二元组（V,E）使得E⊆[V]的平方，所以E的元素是V的2-元子集。为了避免符号上的混淆，我们总是默认V∩B=Ø。集合V中的元素称为图G的定点（或节点、点），而集合E的元素称为边（或线）。
图论外貌：
（ 有点丑别建议哈）
图论特性：没有模板不能活，老死不相往来。
建图方法：边表，邻接矩阵
边表：一般用结构体存储
struct note
{
int y,next,v;//y节点，next下一个，v之间的权值。
}a[E+8]//E为边数
邻接矩阵：用二维数组
bool f[][];//好用极了，但耗空间。表示i与j是否相连。
图论用法：
最短路：共有四种算法：Floyd,Dijkstra,Bellman_Ford,SPFA;
Floyd:是最短四算法中最简单的，但效率不咋地。
主体思路：i点如果和j点相连且j点和k点相连，那么i点和k点相连
优点：容易敲，容易理解，可以处理负权。
缺点：效率低O(n^3),不能处理负环。
void floyd(){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
for(int k=1;k<=n;k++)
if(d[i][k]+d[k][j]<d[i][j]){
d[i][j]=d[i][k]+d[k][j];//只能用邻接矩阵
path[i][j]=k;
}
}
Dijkstra：是最短四算法中效率最高的(Orz,这是谁想出的，辣膜流)
主体思想：使用了广度优先搜索策略，以起始点为中心向外层层扩展，直到扩展到终点为止。
优点：因为遍历是节点多，效率较高O(n^2)
缺点：不能处理负权，且代码复杂。
void dijkstra(int r){
for(int i=1;i<=n;i++)dis[i]=a[r][i];//还是用邻接矩阵，但也可以用邻接表
memset(vis,false,sizeof(vis));//vis用于标记
vis[r]=true;dis[r]=0;//起点赋值
for(int i=1;i<n;i++)//只要循环n-1次
{
int minn=0x3f3f3f3f;
int k=0;
for(int j=1;j<=n;j++)
if((!vis[j])&&(minn>dis[j])){
minn=dis[j];
k=j;
}
}
if(k==0)return;
vis[k]=k;
for(int j=1;j<=n;j++)
if((!vis[j])&&(dis[k]+a[c][j]<dis[j]))
dis[j]=dis[k]+a[k][j];
}
当然，邻接表会更好：
void dijkstra()
{
memset(dis,0x3f3f3f,sizeof(dis));//初始化
vis[1]=1;
dis[1]=0;
for(int i=1;i<=n;++i)
{
int k=0;
for(int j=1;j<=n;++j)//找出距离最近的点
if(!vis[j]&&(k==0||dis[j]<dis[k]))
k=j;
v[k]=1;//加入集合
for(int j=1;j<=n;++j)//松弛
if(!v[j]&&dis[k]+a[k][j]<dis[j])
dis[j]=dis[k]+a[k][j];
}
}
Bellman_Ford:是最短四算法中唯一的只能判断算法，但是效率不高。
主体思想：对边进行松弛，直到无法松弛为止,若松弛次数超过n次，就有负环存在
优点：可以判断负权和负环
缺点：效率不高O（|n|*|E|），并难以做其他操作//E为边
bool Bellman_Ford()//只能判断
{
for(int i=1;i<n;++i)
for(int j=1;j<=e;++j)
relax(edge[j].u,edge[j].v,edge[j].weight);
bool flag=1;
for(int i=1;i<=e;++i)
if(dist[edge[i].v]>dist[edge[i].u]+edge[i].weight)//邻接表！！！
{
flag = 0;
break;
}
return flag;
}
SPFA:Bellman_Ford的优化，用队列维护。
主体思想：在Bellman_Ford的基础下，用队列优化，把枚举值存入队列，队列可以用数组和queue。
优点：频频诈尸，初中阶段称王称霸。
缺点：死了，有神仙数据卡他。
void spfa(int s){
memset(dis,INF,sizeof(dis)); //初始化每点i到s的距离
dis[s]=0;vis[s]=true;q[1]=s; // 队列初始化,s为起点
int v,head=0,tail=1;//队头队尾
while(head<tail){ // 队列非空
head++;
v=q[head]; // 取队首元素
vis[v]=0; // 释放队首结点，因为这节点可能下次用来松弛其它节点，重新入队
for(int i=0; i<=n; i++) // 对所有顶点
if ((a[v][i]>0)and(dis[i]>dis[v]+a[v][i])){
dis[i]=dis[v]+a[v][i]; // 修改最短路
if (!vis[i]){ // 如果扩展结点i不在队列中，入队
q[++tail]=i;
vis[i]=true;
}
}
}
}
最小生成树：共两种算法：Prim,Kruskal。
Prim:
主体思路：将图中的所有顶点分为两类集合：当前在最小生成树中的点集和当前不在最小生成树中的点集，开始时随机抽取一个点，作为起始点，放入最小生成树点集中。然后寻找连接点集中的点和不在点集中的点之间的边的最小值。将这个边放入最小生成树中，把对应连接的顶点放入已在最小生成树中的点集。
void Prim()
{
while(1){//
counter++; //记录边的顺序编号
int minn=56666,pos,start,flag=1;
for(int j = 1;j<=n;j++) { //查找所有连接点集中和非点集中的边的最小边
if(markVertex[j]!=0) {
for (int i=1;i<=n;i++) {
if (markVertex[i]!=0)continue;
if (list[j][i]!=-1 and list[j][i]<minn) {
flag=0;
minn=list[j][i];
pos=i;
start=j;
}
}
}
}
if(flag)break; //如果所有点都在最小生成树中，跳出循环
markEdge[start][pos]=counter; //否则将边导入最小生成树
markVertex[pos]=1; //还有导入对应的集合外的点
}
}//(秀了一波英语，no建议哈)
Kruskal：原理和prim算法差不多，然而kruskal并不是从源点开始层次考察的，而是直接用优先队列存储所有边，通过贪心算法的思想，用权重最小的边组成最小生成树。
并查集三工具准备
int Kruskal(int n,int m)
{
int nEdge = 0, res = 0;
qsort(a, n, sizeof(a[0]), cmp);
for(int i = 0; i < n and nEdge != m - 1; i++){
//判断当前这条边的两个端点是否属于同一棵树
if(find(a[i].a) != find(a[i].b)){
unite(a[i].a, a[i].b);
res += a[i].price;
nEdge++;
}
}
//如果加入边的数量小于m - 1,则表明该无向图不连通,等价于不存在最小生成树
if(nEdge < m-1) res = -1;
return res;
}
小插曲：并查集入门：
只需要知道3个工具：G,M,J
int G(int x)
{
if(father[x]==x)return x;
father[x]=G(father[x]);
return father[x]
}
void M(int x,int y)
{
int fx,fy;
fx=G(x);
fy=G(y);
father[fx]=fy;
}
bool J(int x,int y)
{
int fx,fy;
fx=G(x);
fy=G(y);
return (fx==fy);
}
完成。
———————————————————————————————————————————————
谢谢观看。
万水千山总是情，点赞一下行不行?
扫一扫
168万+
到【灌水乐园】发言
