最短路 模板

Floyd算法

#include <iostream>
//#include <cstring>
#include <algorithm>
const int INF=0x7fffff;
const int maxn=105;
using namespace std;
//最短路更多使用Dijkstra算法，由于耗时短
//需要转化为二维矩阵，dp[i][j]代表从点i到点j的权值
int dp[maxn][maxn],n,x,y,z;
int main()
{
    while(cin>>n>>m)//n个点m条边
    {
        for(int i=0;i<m;i++)
        {
            //输入起点,终点和权值
            cin>>x>>y>>z;
            dp[x][y]=z;//如果是无向图，则map[x][y]=dp[y][x]=z
        }
        //init
        //注意从0开始存还是从1开始存
        //注意别使用memset，容易出问题
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
                dp[i][j]=dp[j][i]=INF;
        }
        //solve
        for(int k=1;k<=n;k++)//最大编号不大于k（可以理解为找到点k）
        {
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
                    //dp[i][j]存的是(当前)从点i到点j的最小权和路径
                    //新找到的点k，新路径权和等于dp[i][k]+dp[k][j],
                    //相当于从i到k，再从k到j
                }
            }
        }
        //print
        //从1点到n点的最小权和路径
        cout<<dp[1][n]<<endl;
    }
    return 0;
}

Dijkstra算法

#include<cstdio>
#include<iostream>
#include<cstring>
#define maxn 105
#define INF 0x7ffffff
using namespace std;
int map[maxn][maxn],n,m,dis[maxn];
void Dijkstra()
{
    int vis[maxn],k;
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)
        dis[i]=map[1][i];
    vis[1]=1;
    for(int i=1;i<n;i++)
    {
        int min=INF;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j] && dis[j]<min)
            {
                min=dis[j];
                k=j;
            }
        }
        vis[k]=1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j] && dis[j]>dis[k]+map[k][j])
                dis[j]=dis[k]+map[k][j];
        }
    }
}
void init()
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            if(i==j)
                map[i][j]=0;
            else
                map[i][j]=INF;
        }
}
void read()
{
    int x,y,time;
    for(int i=0;i<m;i++)
    {
        cin>>x>>y>>time;
        if(map[x][y]>time)//重复边
            map[x][y]=map[y][x]=time;
    }
}
int main()
{
    while(cin>>n>>m && n && m)
    {
        init();
        read();
        Dijkstra();
        cout<<dis[n]<<endl;
    }
    return 0;
}

堆优化的Dijkstra算法

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
const int maxn=10005;
const int INF=0x3f3f3f3f;
using namespace std;
//到达的点和变得权重
struct edge
{
    int v,w;
    edge(int y,int z):v(y),w(z){}
};
//当前状态（当前所处的原点，已经从原点s到u的最短距离w）
struct node
{
    int u,w;
    node(int x,int y):u(x),w(y){}
    friend bool operator < (node a,node b)
    {
        return a.w > b.w;
    }
};
int n,m,dis[maxn],vis[maxn],u,v,w;
vector<edge> e[maxn];

void init()
{
    memset(dis,INF,sizeof(dis));
    memset(vis,0,sizeof(vis));
    for(int i=0;i<maxn;i++)
        e[i].clear();
}

void add_edge(int u,int v,int w)
{
    e[u].push_back(edge(v,w));
}

void Dijkstra_Heap(int s)
{
    priority_queue<node>q;
    q.push(node(s,0));
    dis[s]=0;
    while(!q.empty())
    {
        node cur=q.top();
        q.pop();
        if(vis[cur.u]) continue;
        vis[cur.u]=1;
        for(int i=0;i<e[cur.u].size();i++)
        {
            if(dis[e[cur.u][i].v]>cur.w+e[cur.u][i].w)
            {
                dis[e[cur.u][i].v]=cur.w+e[cur.u][i].w;
                q.push(node(e[cur.u][i].v,dis[e[cur.u][i].v]));
            }
        }
    }
}

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

SPFA算法

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
const int maxn=1005;
const int INF=0x3f3f3f3f;
using namespace std;
int vis[maxn],dis[maxn],cnt[maxn],e[maxn][maxn],n,m,u,v,w;

int SPFA(int s)
{
    queue<int>q;
    q.push(s);
    vis[s]=1,dis[s]=0,cnt[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=1;i<=n;i++)
        {
            if(dis[i]>dis[u]+e[u][i])
            {
                dis[i]=dis[u]+e[u][i];
                if(!vis[i])
                {
                    vis[i]=1;
                    q.push(i);
                    if(++cnt[i]>n) return 0;
                }
            }
        }
    }
    return 1;
}

int main()
{
    while(~scanf("%d%d",&n,&m) && n && m)
    {
        memset(vis,0,sizeof(dis));
        memset(dis,INF,sizeof(dis));
        memset(e,INF,sizeof(e));
        memset(cnt,0,sizeof(cnt));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            if(e[u][v]>w)
            {
                e[u][v]=w;
                e[v][u]=w;
            }
        }
        if(SPFA(1))
            printf("%d\n",dis[n]);
    }
    return 0;
}