洛谷 P3371 【模板】单源最短路径

最新推荐文章于 2023-03-02 12:18:42 发布

NuclearSubmarines

最新推荐文章于 2023-03-02 12:18:42 发布

阅读量399

点赞数

分类专栏： OnlineJudge——洛谷模板

本文链接：https://blog.csdn.net/nuclearsubmarines/article/details/78265852

版权

OnlineJudge——洛谷同时被 2 个专栏收录

13 篇文章 1 订阅

订阅专栏

模板

2 篇文章 0 订阅

订阅专栏

题目描述

如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。

输入输出格式

输入格式：

第一行包含三个整数 $N、M、S$ ，分别表示点的个数、有向边的个数、出发点的编号。

接下来 $M$ 行每行包含三个整数 $F_i、G_i、W_i$ ，分别表示第 $i$ 条有向边的出发点、目标点和长度。

输出格式：

一行，包含 $N$ 个用空格分隔的整数，其中第 $i$ 个整数表示从点 $S$ 出发到点i的最短路径长度（若 $S=i$ 则最短路径长度为 $0$ ，若从点 $S$ 无法到达点 $i$ ，则最短路径长度为 $2147483647$ ）

输入输出样例

输入样例#1：

输出样例#1：

0 2 4 3

说明

时空限制：

1000ms,128M

数据规模：

对于 $20\%$ 的数据： $N\leq5,M\leq15$

对于 $40\%$ 的数据： $N\leq100,M\leq10000$

对于 $70\%$ 的数据： $N\leq1000,M\leq100000$

对于 $100\%$ 的数据： $N\leq10000,M\leq500000$

样例说明：

qwq

solution

$40\%$ 的数据，Floyd模板题
$70\%$ 的数据，dijkstra模板题
$100\%$ 的数据，spfa/堆优化的dijkstra模板题

code

当然是四种算法都有啦！

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;

template<typename T>
void input(T &x) {
    x=0; T a=1;
    register char c=getchar();
    for(;c<'0'||c>'9';c=getchar())
        if(c=='-') a=-1;
    for(;c>='0'&&c<='9';c=getchar())
        x=x*10+c-'0';
    x*=a;
    return;
}

namespace __Floyd {

    const int MAXN=110;
    const int inf=2147483647;

    int dis[MAXN][MAXN];

    void Floyd(int n,int m,int s) {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                dis[i][j]=inf*(i!=j);
        for(int i=1;i<=m;i++) {
            int u,v,w;
            input(u),input(v),input(w);
            if(w<dis[u][v]) dis[u][v]=w;
        }
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    if(i!=j&&i!=k&&j!=k&&dis[i][k]!=inf&&dis[k][j]!=inf)
                        dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
        for(int i=1;i<=n;i++)
            printf("%d ",dis[s][i]);
        return;
    }

}

namespace __dijkstra {

    const int MAXN=1010;
    const int inf=2147483647;

    int G[MAXN][MAXN];
    int dis[MAXN];
    bool vis[MAXN];

    void dijkstra(int n,int m,int s) {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                G[i][j]=inf*(i!=j);
        for(int i=1;i<=m;i++) {
            int u,v,w;
            input(u),input(v),input(w);
            if(w<G[u][v]) G[u][v]=w;
        }
        for(int i=1;i<=n;i++)
            dis[i]=G[s][i],vis[i]=false;
        vis[s]=true;
        for(int k=1;k<n;k++) {
            int Min=inf,u=-1;
            for(int i=1;i<=n;i++)
                if(!vis[i]&&dis[i]<Min)
                    Min=dis[u=i];
            if(u==-1) break;
            vis[u]=true;
            for(int v=1;v<=n;v++)
                if(G[u][v]<inf&&dis[u]+G[u][v]<dis[v])
                    dis[v]=dis[u]+G[u][v];
        }
        for(int i=1;i<=n;i++)
            printf("%d ",dis[i]);
        return;
    }

}

namespace __spfa {

    const int MAXN=10010;
    const int MAXM=500010;
    const int inf=2147483647;

    struct Edge {
        int u,v,w,next;
        Edge(int u=0,int v=0,int w=0,int next=0):
            u(u),v(v),w(w),next(next) {}
    };

    Edge edge[MAXM];
    int head[MAXN],cnt;

    void addedge(int u,int v,int w) {
        edge[++cnt]=Edge(u,v,w,head[u]);
        head[u]=cnt;
        return;
    }

    queue<int> q;
    bool inq[MAXN];
    int dis[MAXN];

    void spfa(int n,int m,int s) {
        for(int i=1;i<=m;i++) {
            int u,v,w;
            input(u),input(v),input(w);
            addedge(u,v,w);
        }
        for(int i=1;i<=n;i++)
            dis[i]=inf,inq[i]=false;
        q.push(s);
        inq[s]=true;
        dis[s]=0;
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            inq[u]=false;
            for(int i=head[u];i;i=edge[i].next) {
                int v=edge[i].v;
                if(dis[u]+edge[i].w<dis[v]) {
                    dis[v]=dis[u]+edge[i].w;
                    if(!inq[v]) {
                        q.push(v);
                        inq[v]=true;
                    }
                }
            }
        }
        for(int i=1;i<=n;i++)
            printf("%d ",dis[i]);
        return;
    }

}

namespace __dijkstra_heap {

    const int MAXN=10010;
    const int MAXM=500010;
    const int inf=2147483647;

    struct Edge {
        int u,v,w,next;
        Edge(int u=0,int v=0,int w=0,int next=0):
            u(u),v(v),w(w),next(next) {}
    };

    Edge edge[MAXM];
    int head[MAXN],cnt;

    void addedge(int u,int v,int w) {
        edge[++cnt]=Edge(u,v,w,head[u]);
        head[u]=cnt;
        return;
    }

    struct Data {
        int dis,x;
        Data(int dis=0,int x=0):
            dis(dis),x(x) {}
        bool operator < (const Data &q)const {
            return dis<q.dis;
        }
        bool operator > (const Data &q)const {
            return dis>q.dis;
        }
    };

    priority_queue<Data,vector<Data>,greater<Data> > heap;
    int dis[MAXN];
    bool vis[MAXN];

    void dijkstra(int n,int m,int s) {
        for(int i=1;i<=m;i++) {
            int u,v,w;
            input(u),input(v),input(w);
            addedge(u,v,w);
        }
        for(int i=1;i<=n;i++)
            dis[i]=inf,vis[i]=false;
        dis[s]=0;
        heap.push(Data(dis[s],s));
        while(!heap.empty()) {
            Data now=heap.top();
            heap.pop();
            int u=now.x;
            if(vis[u]) continue;
            vis[u]=true;
            for(int i=head[u];i;i=edge[i].next) {
                int v=edge[i].v;
                if(dis[u]+edge[i].w<dis[v]) {
                    dis[v]=dis[u]+edge[i].w;
                    heap.push(Data(dis[v],v));
                }
            }
        }
        for(int i=1;i<=n;i++)
            printf("%d ",dis[i]);
        return;
    }

}

int main() {
    int n,m,s;
    input(n),input(m),input(s);
    if(n<=100) __Floyd::Floyd(n,m,s);
    else if(n<=1000) __dijkstra::dijkstra(n,m,s);
    else if(m<=10000) __spfa::spfa(n,m,s);
    else __dijkstra_heap::dijkstra(n,m,s);
    puts("");
    return 0;
}