#include <bits/stdc++.h>

using namespace std;
namespace luosw {
namespace IO {
    template < typename T >
    inline T read() {
        T    ret = 0, f = 1;
        char ch = getchar();
        while (ch < '0' || ch > '9') {
            if (ch == '-')
                f = -f;
            ch = getchar();
        }
        while (ch >= '0' && ch <= '9')
            ret = ret * 10 + ch - '0', ch = getchar();
        return ret * f;
    }
    template < typename T >
    void write(T x) {
        if (x < 0) {
            putchar('-');
            x = -x;
        }
        T y = 10, len = 1;
        while (y <= x) {
            y *= 10;
            len++;
        }
        while (len--) {
            y /= 10;
            putchar(x / y + 48);
            x %= y;
        }
    }
    template < typename T >
    void write(T x, bool flag) {
        if (x < 0) {
            putchar('-');
            x = -x;
        }
        T y = 10, len = 1;
        while (y <= x) {
            y *= 10;
            len++;
        }
        while (len--) {
            y /= 10;
            putchar(x / y + 48);
            x %= y;
        }
        if (flag)
            putchar('\n');
    }
}  // namespace IO
namespace tools {
    template < typename T >
    T cmax(T a, T b) {
        return max(a, b);
    }
    template < typename T >
    T cmin(T a, T b) {
        return min(a, b);
    }
    template < typename T >
    T cgcd(T a, T b) {
        return __gcd(a, b);
    }
    template < typename T >
    T clcm(T a, T b) {
        return a * b / cgcd(a, b);
    }
}  // namespace tools
}  // namespace luosw
#define read(t) t = luosw::IO::read< int >()
#define write(t) luosw::IO::write< int >(t, true)

int dis[100000], vis[100000];
struct Node {
    int  dis, v;
    bool operator<(const Node& a) const {
        return a.dis < this->dis;
    }
};
struct Edge {
    int v, w;
};

vector< Edge >         adj[10000];
priority_queue< Node > q;
int                    s, m, n;
inline void            dijkstra() {
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0;
    vis[s] = 1;
    Node tee;
    tee.dis = dis[s];
    tee.v   = s;
    q.push(tee);
    while (!q.empty()) {
        Node tmp = q.top();
        q.pop();
        int x = tmp.v;
        if (vis[x])
            continue;
        vis[x] = 1;
        for (int i = 0; i < adj[x].size(); i++) {
            if (dis[adj[x][i].v] < dis[x] + adj[x][i].w) {
                dis[adj[x][i].v] = dis[x] + adj[x][i].w;
                if (!vis[adj[x][i].v]) {
                    Node tee;
                    tee.dis = dis[adj[x][i].v];
                    tee.v   = adj[x][i].v;
                    q.push(tee);
                }
            }
        }
    }
}

inline void addEdge(int u, int v, int w) {
    Edge temp;
    temp.v = v;
    temp.w = w;
    adj[u].push_back(temp);
}
signed main() {
    read(n), read(m), read(s);
    for (int i = 0; i < m; i++) {
        int _, __, ___;
        read(_), read(__), read(___);
        addEdge(_, __, ___);
    }
    dijkstra();
    for (int i = 0; i < n; i++) {
        printf("%d ", dis[i]);
    }
#ifdef debug
    system("pause");
#endif
    return 0;
}

刚刚代码错了。

用的是 vector 实现的邻接表存图，加上优先队列优化的。