图论算法
图的存储
- 邻接矩阵
int edg[1010][1010];//邻接矩阵
int main()
{
int n,m;
cin>>n>>m;
for(int i=1;i<=m;i++)
{
int x,y,z;
cin>>x>>y>>z;//x到y权值为z的边
edg[x][y]=z;
}
}
- 邻接表（链式前向星）
#include <bits/stdc++.h>
using namespace std;
int head[100010];
int ver[100010];
int nxt[100010];
int edg[100010];
int tot=0;
inline void add(int x,int y,int z)
{
ver[++tot]=y;
edg[tot]=z;
nxt[tot]=head[x];
head[x]=tot;
}
- 邻接表（vector）
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<vector>
#define N 10000
using namespace std;
struct EDGE
{
int to;//终点
int cost;//边的权值
};
vector<EDGE>G[N];//G[i]中i表示出发点
int m,n;
int temp1;//出发点
int main()
{
scanf("%d%d",&n,&m);
while(m--)
{
EDGE e;
scanf("%d%d%d",&temp1,&e.to,&e.cost);//输入出发点，终点，边的权值
G[temp1].push_back(e);//将数据压入动态数组，表示在这个出发点下引出的边
//相当于二维动态数组
}
return 0;
}
Floyd算法
\(O(n^3)\)
设状态\(f[k][i][j]\):从i到j通过前k个点中的若干个的最短路径和
对于第k个中转点 ：
走：\(f[k-1][i][k]+f[k-1][k][j]\)
不走：\(f[k-1][i][j]\)
显然，可以压缩到二维
#include <bits/stdc++.h>
using namespace std;
struct node
{
int x,y;
} V[10010];
double adm[1010][1010];
double floyd[1010][1010];
int n,m;
int s,t;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
cin>>V[i].x>>V[i].y;
cin>>m;
for(int i=0;i<=n;i++)
{
for(int j=0;j<=n;j++)
{
if(i==j)
{
adm[i][j]=0;//到自己的距离为0
}
else adm[i][j]=0x3f3f3f3f;//初始化
}
}
for(int i=1;i<=m;i++)
{
int a,b;
cin>>a>>b;
adm[a][b]=adm[b][a]=min(sqrt((V[a].x-V[b].x)*(V[a].x-V[b].x)+(V[a].y-V[b].y)*(V[a].y-V[b].y)),adm[a][b]);//松弛
}
cin>>s>>t;
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i!=j&&i!=k&&k!=j)
{
adm[i][j]=min(adm[i][j],adm[i][k]+adm[k][j]); //状转方程
}
}
}
}
cout<<fixed<<setprecision(2)<<adm[s][t];
return 0;
}
Dijkstra算法(不适用负权图)
基本思想：
1. 将图上的初始点看作一个集合S，其它点看作另一个集合
2. 根据初始点，求出其它点到初始点的距离d[i] （若相邻，则d[i]为边权值；若不相邻，则d[i]为无限大）
3. 选取最小的d[i]（记为d[x]），并将此d[i]边对应的点（记为x）加入集合S
（实际上，加入集合的这个点的d[x]值就是它到初始点的最短距离）
4. 再根据x，更新跟 x 相邻点 y 的d[y]值：d[y] = min{ d[y], d[x] + 边权值w[x][y] }，因为可能把距离调小，所以这个更新操作叫做松弛操作。
（仔细想想，为啥只更新跟x相邻点的d[y]，而不是更新所有跟集合 s 相邻点的 d 值？ 因为第三步只更新并确定了x点到初始点的最短距离，集合内其它点是之前加入的，也经历过第 4 步，所以与 x 没有相邻的点的 d 值是已经更新过的了，不会受到影响）
5. 重复3，4两步，直到目标点也加入了集合，此时目标点所对应的d[i]即为最短路径长度。
原文链接
时间复杂度\(O(n^2)\)
#include <bits/stdc++.h>
using namespace std;
const long long int INF=(1<<31)-1;
int edg[2020][2020];//邻接矩阵
int dis[2020];//记录距离
int vis[2020];//集合标记
int n /*点*/,m /*边*/;
int sta/*起点*/,end/*终点*/;
int main()
{
cin>>n>>m>>sta;
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
memset(edg,0x3f,sizeof(edg));
for(int i=1;i<=m;i++)
{
int x/*起点*/,y/*终点*/,z/*边权*/;
cin>>x>>y>>z;
edg[x][y]=min(z,edg[x][y]);//有向图写法
}
dis[sta]=0;
for(int i=1;i<=n;i++)
{
int k=-1;
for(int j=1;j<=n;j++)
{
if(vis[j]==0&&(k==-1||dis[k]>dis[j]))//找到最短的dis
k=j;
}
vis[k]=1;//加入集合(即打上标记
for(int j=1;j<=n;j++)
{
if(!vis[j])
dis[j]=min(dis[j],dis[k]+edg[k][j]);
}//更新相邻点的dis（未相邻的点的 edg 值为无穷大，不会更新
}
for(int i=1;i<=n;i++)
if(dis[i]>=0x3f3f3f3f/2)
cout<<INF<<" ";//无解处理
else cout<<dis[i]<<" ";
return 0;
}
堆优化版Dijkstra
直接使用堆(优先队列)来找最短dis的点
同时使用邻接表(vector或链式前向星实现)降低空间消耗
单次时间复杂度\(O(nlogn)\)
#include <bits/stdc++.h>
using namespace std;
const long long int INF=(1<<31)-1;
int head[1000010];//表头目录
int ver[1000010];//右节点目录
int edge[1000010];//边权值
int nxt[1000010];//第一个与它相连的点的下标
int tot;//邻接表节点个数
int vis[1000010];//集合标记
int dis[1000010];//距离记录
int n /*点*/,m /*边*/;
int sta/*起点*/;
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > q;/*第一维距离，第二维编号*/
inline void add(int x,int y,int z)//建邻接表
{
ver[++tot]=y;
edge[tot]=z;
nxt[tot]=head[x];//下一节点
head[x]=tot;
}
int main()
{
cin>>n>>m>>sta;
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
for(int i=1;i<=m;i++)
{
int x,y,z;
cin>>x>>y>>z;
add(x,y,z);
}
dis[sta]=0;
q.push(make_pair(0,sta));//首元素入队列
while(!q.empty())
{
int x=q.top().second;//利用优先队列（堆）直接找到最短dis的点
q.pop();
if(vis[x]) continue;
vis[x]=1;//加入集合
for(int i=head[x];i;i=nxt[i])//链表遍历
{
int y=ver[i],z=edge[i];
if(dis[y]>dis[x]+z)
{
dis[y]=dis[x]+z;
q.push(make_pair(dis[y],y));//更新元素入队
}
}
}
for(int i=1;i<=n;i++)
{
cout<<dis[i]<<" ";
}
return 0;
}
SPFA
它死了 （天天被卡
\(SPFA\)(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
是\(Bellman-Ford\)算法的一种队列实现，减少了不必要的冗余计算。
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，
并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
时间复杂度最坏为\(O(VE)\)(极不稳定容易被卡)
#include <bits/stdc++.h>
using namespace std;
const int INF=(1<<31)-1;
int head[1000010];
int nxt[1000010];
int edge[1000010];
int ver[1000010];
int tot;//邻接表
int dis[1000010];//记录最短路
int vis[1000010];//记录是否入队列
int num[1000010];//记录入队次数
int n/*点数*/,m/*边数*/,q;
inline void add(int x,int y,int z)
{
ver[++tot]=y;
edge[tot]=z;
nxt[tot]=head[x];
head[x]=tot;
}
bool SPFA(int s)//传参传源点编号
{
queue<int> q;
memset(dis,0x3f,sizeof(dis));
memset(vis,0,sizeof(vis));
memset(num,0,sizeof(num));
dis[s]=0;//初始化源点距离
vis[s]=1,num[s]++;//标记源点
q.push(s);//源点入队
while(!q.empty())
{
int x=q.front();
q.pop();
vis[x]=0;//出队取消标记
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i],z=edge[i];
if(dis[y]>dis[x]+z)
{
dis[y]=dis[x]+z;
// cout<<x<<' '<<y<<' '<<dis[y]<<' '<<dis[x]<<endl;
if(!vis[y]) //当前点不在队列中
{
q.push(y);//入队
vis[y]=1;//标记
num[y]++;
if(num[y]>n) return false;//如果这个点入队超过n次，判负环
}
}
}
}
return true;
}
int main()
{
cin>>n>>m>>q;
for(int i=1;i<=m;i++)
{
int x,y,z;
cin>>x>>y>>z;
add(x,y,z);
}
bool flag=SPFA(q);
if(flag==0)
{
cout<<INF;
return 0;
}
for(int i=1;i<=n;i++)
{
if(dis[i]<0x3f3f3f3f) cout<<dis[i]<<" ";
else cout<<INF<<' ';
}
return 0;
}
拓补排序
对一个有向无环图 (Directed Acyclic Graph简称DAG) \(G\)进行拓扑排序，是将\(G\)中所有顶点排成一个线性序列，使得图中任意一对顶点\(u\)和\(v\)，若边\(<u,v>∈E(G)\)，则\(u\)在线性序列中出现在\(v\)之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。
拓扑排序算法主要是循环执行以下两步，直到不存在入度为\(0\)的顶点为止。
(1).选择一个入度为\(0\)的顶点并输出之；
(2).从网中删除此顶点及所有出边。
循环结束后，若输出的顶点数小于网中的顶点数，则输出“有回路”信息，否则输出的顶点序列就是一种拓扑序列。
注意：这里得到的排序并不是唯一的！ 就好像你早上穿衣服可以先穿上衣也可以先穿裤子，只要里面的衣服在外面的衣服之前穿就行。
#include <bits/stdc++.h>
using namespace std;
int head[1000010];
int ver[1000010];
int nxt[1000010];
int tot=0;
int n,m;
int num[1000010];
int ind[1000010];
int oud[1000010];
int all=0;
queue<int> q;
inline void add(int x,int y)//链式前向星存图
{
ver[++tot]=y;
nxt[tot]=head[x];
head[x]=tot;
}
void topo()//拓补核心函数
{
while(!q.empty())
{
int x=q.front();
q.pop();
all++;//记录出队标号
num[all]=x;
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
ind[y]--;//删除出边，则出边所连接点的入度-1
if(ind[y]==0) q.push(y);//入度为 0，入队准备扩展
}
}
if(all==n)
{
for(int i=1;i<=all;i++)
cout<<num[i]<<" ";//输出序列
}
else cout<<"有回路";
}
int main()
{
cin>>n>>m;
for(int i=1;i<=m;i++)
{
int x,y;
cin>>x>>y;
add(x,y);
ind[y]++;oud[x]++;//统计出入度
}
for(int i=1;i<=n;i++)
{
if(ind[i]==0)
q.push(i);
}
topo();
return 0;
}
未完待续......
------------------------------------------------------------------------------少女祈祷中......
