最短路 floyd dijkstra 模板

1、floyd（鄰接矩陣）

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#define MAX 1005
using namespace std;
const int INF=0x3f3f3f3f;

int n,m;
int main(){
    while(~scanf("%d%d",&n,&m)){
        if(n==0)    printf("0\n");
        stack<char> s;
        while(n){
            if(n%m>=10)
                s.push('A'+n%m-10);
            else
                s.push('0'+n%m);
            n=n/m;
        }
        while(!s.empty()){
            printf("%c ",s.top());
            s.pop();
        }
        printf("\n");
    }
    return 0;
}

2、dijkstra()(鄰接表)

//dijkstra()(鄰接表)
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define MAX 1005

const int INF=0x3f3f3f3f;
using namespace std;

typedef struct {
    int u,v,w;
} edge;
vector<edge> edges;
vector<int> G[MAX];
int dis[MAX],book[MAX];
int n,m;

void dijkstra() {
    memset(book,0,sizeof(book));
    memset(dis,0x3f,sizeof(dis));dis[1]=0;
    while(1) {
        int t,minx=INF;
        for(int j=1; j<=n; j++)
            if(!book[j]&&dis[j]<minx)   minx=dis[t=j];
        book[t]=1;

        if(minx==INF)break;
        for(int j=0; j<(int)G[t].size(); j++) {
            edge e=edges[G[t][j]];
            dis[e.v]=min(dis[e.v],dis[t]+e.w);
        }
    }
}
void init() {
    for(int i=0; i<n; i++)G[i].clear();
    edges.clear();
}
void AddEdge(int u,int v,int w) {
    edges.push_back(edge{u,v,w});
    int m=edges.size();
    G[u].push_back(m-1);
}

int main() {
    while(~scanf("%d%d",&n,&m)&&n&&m) {
        int u,v,w;
        init();
        for(int i=0; i<m; i++) {
            scanf("%d%d%d",&u,&v,&w);
            AddEdge(u,v,w);
            AddEdge(v,u,w);
        }
        dijkstra();
        printf("%d\n",dis[n]);
    }
    return 0;
}

3、dijkstra()(鄰接表，最小堆優化)

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <queue>
#define MAX 1005
using namespace std;
const int INF=0x3f3f3f3f;

struct heap{
    int w,x;
    bool operator<(const heap& h) const{
        return w>h.w;
    }
};

typedef struct {
    int u,v,w;
}edge;
vector<edge>edges;
vector<int>G[MAX];
int n,m;
int dis[MAX],book[MAX];

void AddEdge(int u,int v,int w){
    edges.push_back(edge{u,v,w});
    int m=edges.size();
    G[u].push_back(m-1);
}

void dijkstra(){
    memset(dis,0x3f,sizeof(dis));dis[1]=0;
    memset(book,0,sizeof(book));
    priority_queue<heap> q;
    q.push(heap{0,1});
    while(!q.empty()){
        heap h=q.top();
        q.pop();
        if(book[h.x])   continue;
        book[h.x]=1;
        for(int i=0;i<G[h.x].size();i++){
            edge e=edges[G[h.x][i]];
            dis[e.v]=min(dis[e.v],dis[h.x]+e.w);
            q.push(heap{dis[e.v],e.v});
        }
    }
}

int main(){
    while(scanf("%d%d",&n,&m)==2&&n&&m){
        for(int i=1;i<=n;i++)   G[i].clear();
        edges.clear();
        int u,v,w;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&w);
            AddEdge(u,v,w);
            AddEdge(v,u,w);
        }
        dijkstra();
        printf("%d\n",dis[n]);
    }
    return 0;
}

4、//dijkstra()(鄰接表，最小堆，打印路徑)

//dijkstra()(鄰接表，最小堆，打印路徑)
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <queue>
#define MAX 1005
using namespace std;
const int INF=0x3f3f3f3f;

struct heap{
    int w,x;
    bool operator<(const heap& h) const{
        return w>h.w;
    }
};

typedef struct {
    int u,v,w;
}edge;
vector<edge>edges;
vector<int>G[MAX];
int n,m;
int dis[MAX],book[MAX];
int fa[MAX];

void AddEdge(int u,int v,int w){
    edges.push_back(edge{u,v,w});
    int m=edges.size();
    G[u].push_back(m-1);
}

void dijkstra(){
    memset(dis,0x3f,sizeof(dis));dis[1]=0;
    memset(book,0,sizeof(book));
    priority_queue<heap> q;
    q.push(heap{0,1});
    while(!q.empty()){
        heap h=q.top();
        q.pop();
        if(book[h.x])   continue;
        book[h.x]=1;
        for(int i=0;i<(int)G[h.x].size();i++){
            edge e=edges[G[h.x][i]];
            #dis[e.v]=min(dis[e.v],dis[h.x]+e.w);
            if(dis[e.v]>dis[h.x]+e.w){
                dis[e.v]=dis[h.x]+e.w;
                fa[e.v]=h.x;
                q.push(heap{dis[e.v],e.v});
            }
        }
    }
}

void print(int x){
    if(x==1){
        printf("%d ",x);
        return;
    }
    print(fa[x]);
    printf("%d ",x);
}

int main(){
    while(scanf("%d%d",&n,&m)==2&&n&&m){
        for(int i=1;i<=n;i++)   G[i].clear();
        edges.clear();
        int u,v,w;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&w);
            AddEdge(u,v,w);
            AddEdge(v,u,w);
        }
        dijkstra();
        printf("%d\n",dis[n]);
        print(n);printf("\n");
    }
    return 0;
}

5、//flyod 打印路徑

//flyod 打印路徑
//
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <queue>
#define MAX 1005
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
int a[MAX][MAX],nex[MAX][MAX];

void floyd(){
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++){
                if(a[i][j]>a[i][k]+a[k][j]){
                    a[i][j]=a[i][k]+a[k][j];
                    nex[i][j]=nex[i][k];
                }
        }
}

void print(int x){
    printf("%d ",x);
    if(x==n){putchar(10);return;}
    print(nex[x][n]);

}

int main(){
    while(scanf("%d%d",&n,&m)==2&&n&&m){
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++){
                if(i==j)    a[i][j]=0;
                else a[i][j]=INF;
                nex[i][j]=j;
            }

        for(int i=0;i<m;i++){
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            a[u][v]=w;
            a[v][u]=w;
        }
        floyd();
        printf("%d\n",a[1][n]);
        print(1);
    }
    return 0;
}