caminho mais curto
caminho mais curto de origem única
Todos os pesos das arestas são positivos
Algoritmo Ingênuo de Dijkstra
Ideia básica: a distância mais curta do ponto 1 a outros pontos
etapa:
Defina um conjunto contendo os pontos com a menor distância determinada atualmente
1. Distância de inicialização dis[1] = 0, dis[other] = infinito positivo
2. para i 0-n loop n vezes
2.1 Encontre o ponto mais próximo que não está em s -> t
2.2 Adicione t a s
2.3 Use t para atualizar a distância de outros pontos
O código do modelo é o seguinte:
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 510;
int n,m;
int g[N][N];
//dis表示从1号点到其它点的距离
int dist[N];
//st表示每个点的最短路是否确定
bool st[N];
int dijkstra()
{
memset(dist,0x3f,sizeof dist);
dist[1] = 0;
for(int i = 0;i < n; i ++)
{
int t = -1;
for(int j = 1;j <= n;j ++)
if(!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
st[t] = true;
for(int j = 1;j <= n;j ++)
dist[j] = min(dist[j],dist[t] + g[i][j]);
}
if(dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
//初始化
memset(g,0x3f,sizeof g);
int t = dijkstra();
printf("%d\n",t);
return 0;
}
Versão otimizada para heap do algoritmo de Dijkstra
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queque>
using namespace std;
const int N = 100010;
int n,m;
//存储方式改为邻接表的形式
int h[N],w[N],e[N],ne[N],idx;
//dis表示从1号点到其它点的距离
int dist[N];
//st表示每个点的最短路是否确定
bool st[N];
void add(int a,int b,int c)
{
e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx ++;
}
int dijkstra()
{
memset(dist,0x3f,sizeof dist);
dist[1] = 0;
priority_queue<PII,vector<PII>,greater<PII>> heap;
heap.push({0,1});
while(heap.size --)
{
auto t = heap.top();
heap.pop();
int ver = t.second,distance = t.first();
if (st[ver]) continue;
for(int i = h[ver];i != -1;i = ne[i])
{
int j = e[i];
if(dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j],j});
}
}
}
if(dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
//初始化
memset(h,-1,sizeof h);
while(m --)
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
}
int t = dijkstra();
printf("%d\n",t);
return 0;
}
Existem arestas ponderadas negativas
Algoritmo Bellman-Ford
Ideia básica: n iterações, todas as arestas são cicladas a cada vez e a distância mais curta é atualizada a cada ciclo
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int M = 100010, N = 510;
int n,m,k;
int dist[N],backup[N];
struct Edge
{
int a,b,w;
}edges[M];
int bellman_ford()
{
memset(dist,0x3f,sizeof dist);
dist[1] = 0;
for(int i = 0;i < k;i ++)
{
//保存上一次的结果
memcpy(backup,dist,sizeof dist);
for(int j = 0;j < m;j ++)
{
int a = edges[j].a,b = edges[j].b,w = edges[j].w;
dist[b] = min(dist[b],backup[a] + w);
}
}
if(dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
int main()
{
scanf("%d%d%d",&n,&m,&k);
for(int i = 0;i < m;i ++)
{
int a,b,w;
scanf("%d%d%d",&a,&b,&w);
edges[i] = {a,b,w};
}
int t = bellman_ford();
if(t == -1)
{
puts("impossible");
}
else printf("%d\n",t);
return 0;
}
Algoritmo SPFA
Uma otimização do algoritmo Bellman-Ford
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queque>
using namespace std;
const int N = 100010;
int n,m;
//存储方式改为邻接表的形式
int h[N],w[N],e[N],ne[N],idx;
//dis表示从1号点到其它点的距离
int dist[N];
//st表示每个点的最短路是否确定
bool st[N];
void add(int a,int b,int c)
{
e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx ++;
}
int spfa()
{
memset(dist,0x3f,sizeof dist);
queue<int> q;
q.push(1);
st[1] = true;
while(q.size())
{
int 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])
{
q.push(j);
st[j] = true;
}
}
}
}
if(dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
//初始化
memset(h,-1,sizeof h);
while(m --)
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
}
int t = spfa();
if(t == -1) puts("false");
else printf("%d\n",t);
return 0;
}
Caminho mais curto do coletor de várias fontes
Floyd
Use matriz crítica para armazenar
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 210,INF = 1e9;
int n,m,Q;
int d[N][N];
void floyd()
{
for(int k = 1;k <= n;k ++)
for(int i = 1;i <= n;i ++)
for(int j = 1;j <= n;j ++)
d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
}
int main()
{
scanf("%d%d%d",&n,&m,&Q);
for(int i = 1;i <= n;i ++)
{
for(int j = 1;j <= n;j ++)
if(i == j) d[i][j] = 0;
else d[i][j] = INF;
}
while(m --)
{
int a,b,w;
scanf("%d%d%d",&a,&b,&w);
d[a][b] = min(d[a][b],w);
}
floyd();
while(Q --)
{
int a,b;
scanf("%d%d",&a,&b);
if(d[a][b] > INF / 2) puts("impossible");
printf("%d\n",d[a][b]);
}
return 0;
}