最短路
最短路:
单元最短路
所有边权都是正数
朴素Dijkstra算法 稠密图 O(n2)
堆优化Dijkstra算法 稀疏图 O(mlogn)
存在负权边
Bellman-Ford O(nm)
SPFA 一般为O(m),最坏为O(nm)
多源汇最短路 Floyd算法 O(n3)
朴素Dijkstra算法
//算法模板
int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 存储每个点的最短路是否已经确定
// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < n - 1; i ++ )
{
int t = -1; // 在还未确定最短路的点中，寻找距离最小的点
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
// 用t更新其他点的距离
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
st[t] = true;
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
//Dijkstra求最短路,测试实例
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510;
int g[N][N];
int dis[N];
bool st[N];
int n,m;
int Dijkstra(){
memset(dis,0x3f,sizeof dis);//初始化距离为无穷远
dis[1] = 0;//自己到自己
for(int i = 0 ;i<n;i++){
int t = -1;//当前访问的点
for(int j = 1;j<=n;j++){
if(!st[j]&&(t==-1||dis[t]>dis[j]))//该步骤即寻找还未确定最短路的点中路径最短的点
t=j;
}
st[t] = true;
for(int j = 1;j<=n;j++){//跟新每个点到相邻点的点路径值
dis[j] = min(dis[j],dis[t]+g[t][j]);
}
}
if(dis[n]==0x3f3f3f3f) return -1;
else return dis[n];
}
int main(){
scanf("%d%d",&n,&m);
memset(g,0x3f,sizeof g);
int a,b,c;
while(m--){
scanf("%d%d%d",&a,&b,&c);
g[a][b] = min(g[a][b],c);
}
printf("%d",Dijkstra());
return 0;
}
堆优化Dijkstra算法
// 堆优化Dijkstra算法模板
typedef pair<int, int> PII;
int n; // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定
// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1}); // first存储距离，second存储节点编号
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
st[ver] = true;
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];
}
//Dijkstra求最短路,测试实例
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int ,int> PII;
const int N = 150010;
int h[N],e[N],ne[N],idx;//稀疏图用邻接表
int w[N];//权重
int dis[N];
bool st[N];
int n,m;
void add(int a,int b,int c){
w[idx] = c;
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
int dijkstra(){
memset(dis,0x3f,sizeof(dis));
dis[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap; // 定义一个小根堆
heap.push({0,1});//距离和序号
while(heap.size()){
PII k =heap.top();
heap.pop();
int ver = k.second, distance = k.first;
if(st[ver]) continue;
st[ver] = true;
for(int i = h[ver];i!=-1;i=ne[i]){
int j = e[i];
if(dis[j]>distance+w[i]){
dis[j] = distance+w[i];
heap.push({dis[j],j});
}
}
}
if(dis[n]==0x3f3f3f3f) return -1;
else return dis[n];
}
int main(){
memset(h,-1,sizeof(h));
scanf("%d%d",&n,&m);
int a,b,c;
while(m--){
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
}
printf("%d",dijkstra());
return 0;
}
Bellman-Ford 算法
//模板
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];
}
//有边数限制的最短路
#include<iostream>
#include<cstring>
using namespace std;
const int N = 510,M = 10010;
int n,m,k;
int dis[N],back[N];
struct edge{
int a;
int b;
int w;
}e[M];
int bellman_ford(){
memset(dis,0x3f,sizeof dis);
dis[1] = 0;
for(int i = 0;i<k;i++){
memcpy(back,dis,sizeof dis);
for(int j = 0;j<m;j++){
int a = e[j].a;
int b = e[j].b;
int w = e[j].w;
dis[b] = min(dis[b],back[a]+w);
}
}
if(dis[n]> 0x3f3f3f3f / 2) return 0x3f3f3f3f;
else return dis[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);
e[i] = {a,b,w};
}
int res = bellman_ford();
if(res == 0x3f3f3f3f) puts("impossible");
else printf("%d",res);
return 0;
}
SPFA算法
求解最短路
//算法模板---求最短路
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求解最短路
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N = 1e5+10;
int h[N],e[N],en[N],we[N],idex=0;
bool st[N];
int dis[N];
int n,m;
void add(int a,int b,int w){
e[idex] = b;
we[idex] = w;
en[idex] = h[a];
h[a] = idex++;
}
int spfa(){
memset(dis,0x3f,sizeof dis);
dis[1] = 0;
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=en[i]){
int j = e[i];
if(dis[j]>dis[t]+we[i]){
dis[j] = dis[t]+we[i];
if(!st[j]){
q.push(j);
st[j] = true;
}
}
}
}
return dis[n];
}
int main(){
memset(h,-1,sizeof h);
int a,b,w;
cin>>n>>m;
for(int i = 0;i<m;i++){
cin>>a>>b>>w;
add(a,b,w);
}
int t = spfa();
if(t == 0x3f3f3f3f) puts("impossible");
else printf("%d",t);
return 0;
}
判断是否存在负环
//算法模板
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;
}
//spfa判断负环
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N = 10010;
int h[N],e[N],ne[N],we[N],idex;
bool st[N];
int n,m;
int dis[N],cnt[N];
int add(int a,int b,int w){
e[idex] = b;
we[idex] = w;
ne[idex] = h[a];
h[a] = idex++;
}
bool spfa(){
memset(dis,0x3f,sizeof dis);
queue<int> q;
for(int i = 1;i<=n;i++){
q.push(i);
st[i] = 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(dis[j]>dis[t]+we[i]){
dis[j] = dis[t]+we[i];
cnt[j] = cnt[t]+1;
if(cnt[j]>=n) return true;
if(!st[j]){
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
int main(){
int a,b,w;
memset(h,-1,sizeof h);
cin>>n>>m;
for(int i = 0;i<m;i++){
cin>>a>>b>>w;
add(a,b,w);
}
if(spfa()) puts("Yes");
else puts("No");
return 0;
}
Floyd算法
//算法模板
初始化：
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;
// 算法结束后，d[a][b]表示a到b的最短距离
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]);
}
//Floyd求最短路
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 210,INF = 1e9;
int d[N][N];
int n,m,q;
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(){
cin>>n>>m>>q;
int a,b,w;
int x,y;
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--){
cin>>a>>b>>w;
d[a][b] = min(d[a][b],w);
}
floyd();
while(q--){
cin>>x>>y;
if(d[x][y]>INF/2) puts("impossible");
else printf("%d\n",d[x][y]);
}
return 0;
}
vscode验证
扫一扫
531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
