单源最短路问题

1.bellman-ford

#include<iostream>
#define INF 1000000
using namespace std;
struct edge
{
    int from,to,cost;
    edge(){}
    edge(int ff,int tt,int cc)
    {
        from=ff;
        to=tt;
        cost=cc;
    }
};
const int maxn=105;
const int maxe=10005;
int d[maxn];
edge es[maxe];
int v,e;

void bellman_ford(int s)
{
    fill(d,d+v,INF);
    d[s]=0;
    while(true)
    {
        bool update=false;
        for(int i=0;i<e;i++)
        {
            edge e=es[i];
            if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost)
            {
                d[e.to]=d[e.from]+e.cost;
                update=true;
            }
        }
        if(!update) break;
    }
    for(int i=0;i<v;i++)
    {
        cout<<d[i]<<endl;
    }
}
//如果返回true则存在复圈
bool find_negative_loop()
{
    fill(d,d+v,INF);
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<e;j++)
        {
            edge e=es[j];
            if(d[e.to]>d[e.from]+e.cost)
            {
                d[e.to]=d[e.from]+e.cost;

                //如果第n次仍然更新了，则存在负圈
                if(i==v-1) return true;
            }
        }
    }
    return false;
}
int main()
{
    cin>>v>>e;
    int from,to,cost;
    for(int i=0;i<e;i++)
    {
        cin>>from>>to>>cost;
        from--;
        to--;
        es[i]=edge(from,to,cost);
    }
    //cout<<find_negative_loop();
    bellman_ford(0);
    return 0;
}

2.dijkstra

#include<bits/stdc++.h>
#define INF 1000000
using namespace std;
const int maxn=1010;
//邻接矩阵形式
int cost[maxn][maxn];
int used[maxn];
int d[maxn];
int n;
int prev[maxn];//最短路上所有前驱结点
vector<int> get_path(int t)
{
    vector<int> path;
    for(;t!=-1;t=prev[t])
        path.push_back(t);//不断沿着prev[t]走直到t=s
    reverse(path.begin(),path.end());
    return path;
}
void dijkstra(int s)
{
    fill(d,d+n,INF);
    fill(used,used+n,0);
    fill(prev,prev+n,-1);
    d[s]=0;
    while(true)
    {
        int v=-1;
        for(int u=0; u<n; u++)
        {
            if(!used[u]&&(v==-1||d[u]<d[v]))
            {
                v=u;
            }
        }
        if(v==-1) break;//所有节点都计算完毕
        used[v]=1;
        for(int u=0; u<n; u++)
        {
            if(d[u]>d[v]+cost[v][u])
            {
                d[u]=d[v]+cost[v][u];
                prev[u]=v;
            }
        }
    }
    for(int i=0; i<n; i++)
    {
        cout<<d[i]<<endl;
    }

    vector<int> path=get_path(n-1);
    for(int i=0;i<path.size();i++)
    {
        cout<<path[i]<<" ";
    }
}

int main()
{
    cin>>n;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            cin>>cost[i][j];
        }
    }
    dijkstra(0);
    return 0;
}
/*
测试数据 教科书 P189 G6 的邻接矩阵 其中 数字 1000000 代表无穷大
6
1000000 1000000 10      100000      30      100
1000000 1000000 5       1000000     1000000 1000000
1000000 1000000 1000000 50          1000000 1000000
1000000 1000000 1000000 1000000     1000000 10
1000000 1000000 1000000 20          1000000 60
1000000 1000000 1000000 1000000     1000000 1000000
结果：
D[0]   D[1]   D[2]   D[3]   D[4]   D[5]
 0   1000000   10     50     30     60
*/

3.堆优化的dijkstra

#include<iostream>
#include<vector>
#include<queue>
#define INF 1000000
using namespace std;
typedef pair<int,int> P; //first代表最短距离，second代表顶点的编号
//邻接表
struct edge
{
    int to,cost;
    edge(int tt,int cc)
    {
        to=tt;
        cost=cc;
    }
};
const int maxn=105;
vector<edge> G[maxn];
int d[maxn];
int n;
void heap_dijkstra(int s)
{
    fill(d,d+n,INF);
    priority_queue<P,vector<P>,greater<P> > que;
    que.push(P(0,s));
    d[s]=0;
    while(!que.empty())
    {
        P p=que.top();
        que.pop();
        int v=p.second;
        if(p.first>d[v]) continue;
        for(int i=0;i<G[v].size();i++)
        {
            edge e=G[v][i];
            if(d[e.to]>d[v]+e.cost)
            {
                d[e.to]=d[v]+e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
    for(int i=0;i<n;i++)
        cout<<d[i]<<endl;
}
int main()
{
    cin>>n;
    int from,to,cost;
    for(int i=0;i<n;i++)
    {
        cin>>from>>to>>cost;
        from--;
        to--;
        G[from].push_back(edge(to,cost));
        G[to].push_back(edge(from,cost));
    }

    heap_dijkstra(0);
    return 0;
}

4.floyd_warshall

#include<iostream>
#include<memory.h>
#define INF 1000000
using namespace std;
const int maxn=105;
int d[maxn][maxn];
int n;
//任意两点间的最短路问题,dp
void floyd_warshall()
{
    for(int i=0; i<n; i++)
        d[i][i]=0;

    for(int k=0; k<n; k++)
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);

    for(int i=0; i<n; i++)
        cout<<d[0][i]<<endl;
}
int main()
{
    memset(d,INF,sizeof(d));
    cin>>n;
    for(int i=0; i<n; i++)
        for(int j=0; j<n; j++)
            cin>>d[i][j];

    floyd_warshall();
    return 0;
}

5.spfa

#include<iostream>
#include<stdio.h>
#include<vector>
#include<queue>
using namespace std;
#define inf 99999999
typedef struct dd
{
    int a,d;
}node;
int dis[20005],n;
vector<node> maps[20005];
void sets()
{
    for(int i=1;i<=n;i++)
    {
        dis[i]=inf;
    }
}
void spfa()
{
    queue<int> q;
    int b[20005]={0},t;//b数组标识节点是否在队列中
    q.push(1);//起点入队
    b[1]=1;   //标记
    dis[1]=0; //距离
    while(!q.empty())
    {
        //队首元素出队
        t=q.front();
        q.pop();
        //标记
        b[t]=0;
        //这个点作为起点的路径有多少
        int len=maps[t].size();
        int a;
        for(int i=0;i<len;i++)
        {
            //这条路径的终点
            a=maps[t][i].a;
            if(dis[a]>maps[t][i].d+dis[t])
            {
                dis[a]=maps[t][i].d+dis[t];
                if(!b[a])
                {
                    b[a]=1;
                    q.push(a);
                }
            }
        }
    }
}
int main()
{
    int m,a,b,l;
    node Now;
    while(scanf("%d%d",&n,&m)==2)
    {
        sets();
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&l);
            Now.a=b;
            Now.d=l;
            maps[a].push_back(Now);
        }
        spfa();
        for(int i=2;i<=n;i++)
        {
            printf("%d
",dis[i]);
        }
    }
    return 0;
}