Floyd算法
三重for循环配合数组暴力求解
很容易理解,但是也很容易tle,核心代码三重for循环顺序没有要求
最好别用??
memset(mp,0x3f,sizeof(mp));
for(int i=1;i<=n;i++)
mp[i][i]=0;
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&a,&b,&c);
mp[a][b]=mp[b][a]=c;
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
mp[j][i]=mp[i][j];
}
}
}
迪杰斯特拉算法
标准板子题
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=500;
int mp[maxn][maxn],dis[maxn],book[maxn];
int main()
{
int m,n,s,t,a,b,c;
while(cin>>n>>m)
{
memset(mp,0x3f,sizeof(mp));
memset(dis,0,sizeof(dis));
memset(book,0,sizeof(book));
for(int i=0;i<=n-1;i++)
mp[i][i]=0;
while(m--)
{
scanf("%d%d%d",&a,&b,&c);
mp[a][b]=mp[b][a]=min(c,mp[b][a]);
}
cin>>s>>t;
for(int i=0;i<=n-1;i++)
dis[i]=mp[s][i];
book[s]=1;
int minn=0x3f3f3f3f,u;
for(int i=1;i<=n-1;i++)
{
minn=0x3f3f3f3f;
for(int j=0;j<=n-1;j++)
{
if(book[j]==0&&dis[j]<minn)
{
minn=dis[j];u=j;
}
}
book[u]=1;
for(int k=0;k<=n-1;k++)
{
if(mp[u][k]!=0x3f3f3f3f)
{
dis[k]=min(dis[u]+mp[u][k],dis[k]);
}
}
}
if(dis[t]!=0x3f3f3f3f)
printf("%d\n",dis[t]);
else
printf("-1\n");
}
}
dis[i]表示的是起点到i点的最小距离。
思路可以理解为,dis[i]最初为起点到i点最小距离的估计值,当dis[i]被发现为最小时,则可以认为dis[i]由估计值变化为确定值(既然两点已经最小,则不可能在通过第三个点中转),随后利用dis[i]对其他dis进行松弛操作,如此操作n-1轮,直至所有估计值全部都变成确定值。
spfa+链式前向星
int dis[1000005],head[1000005],vis[1000005],num=0;//dis=0x3f,head=-1
struct road
{
int b,c,nex;
}r[2000005];
void add(int a,int b,int c)
{
r[num].b=b;
r[num].c=c;
r[num].nex=head[a];
head[a]=num++;
}
void spfa(int num)
{
queue<int>q;
dis[num]=0;
q.push(num);
vis[num]=1;
while(!q.empty())
{
int k=q.front();
q.pop();
vis[k]=0;
for(int i=head[k];i!=-1;i=r[i].nex)
{
if(dis[r[i].b]>dis[k]+r[i].c)
{
dis[r[i].b]=dis[k]+r[i].c;
if(vis[r[i].b]==0)
{
q.push(r[i].b);
vis[r[i].b]=1;
}
}
}
}
}
Bellman-Ford算法 —— 模板题 AcWing 853. 有边数限制的最短路
时间复杂度 O(nm)O(nm), nn 表示点数,mm 表示边数
注意在模板题中需要对下面的模板稍作修改,加上备份数组,详情见模板题。
int n, m; // n表示点数,m表示边数
int dist[N]; // dist[x]存储1到x的最短路距离
struct Edge // 边,a表示出点,b表示入点,w表示边的权重
{
int a, b, w;
}edges[M];
// 求1到n的最短路距离,如果无法从1走到n,则返回-1。
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 如果第n次迭代仍然会松弛三角不等式,就说明存在一条长度是n+1的最短路径,由抽屉原理,路径中至少存在两个相同的点,说明图中存在负权回路。
for (int i = 0; i < n; i ++ )
{
for (int j = 0; j < m; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
if (dist[b] > dist[a] + w)
dist[b] = dist[a] + w;
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
spfa 算法(队列优化的Bellman-Ford算法) —— 模板题 AcWing 851. spfa求最短路
时间复杂度 平均情况下 O(m)O(m),最坏情况下 O(nm)O(nm), nn 表示点数,mm 表示边数
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储每个点到1号点的最短距离
bool st[N]; // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离,如果从1号点无法走到n号点则返回-1
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j]) // 如果队列中已存在j,则不需要将j重复插入
{
q.push(j);
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
spfa判断图中是否存在负环 —— 模板题 AcWing 852. spfa判断负环
时间复杂度是 O(nm)O(nm), nn 表示点数,mm 表示边数
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离,cnt[x]存储1到x的最短路中经过的点数
bool st[N]; // 存储每个点是否在队列中
// 如果存在负环,则返回true,否则返回false。
bool spfa()
{
// 不需要初始化dist数组
// 原理:如果某条最短路径上有n个点(除了自己),那么加上自己之后一共有n+1个点,由抽屉原理一定有两个点相同,所以存在环。
queue<int> q;
for (int i = 1; i <= n; i ++ )
{
q.push(i);
st[i] = true;
}
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1;
if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点(不包括自己),则说明存在环
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
作者:yxc
链接:https://www.acwing.com/blog/content/405/
来源:AcWing
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。