#include <bits/stdc++.h>
#define ll long long
using namespace std;

const int INF = INT_MAX; // 定义 INF 为最大整数，用于初始化最短距离，代表不可达的距离

int main() {
    int n, m;  // n: 顶点数，m: 边数
    cin >> n >> m;  // 输入图的顶点数 n 和边数 m

    // 使用邻接表存储图，adj[i] 存储从顶点 i 出发的所有边 (v, w)，其中 v 是邻接点，w 是边的权重
    vector<vector<pair<int, int>>> adj(n + 1);

    // 输入每条边的信息
    for (int i = 0; i < m; i++) {
        int u, v, w; // u 和 v 为边的两个端点，w 为边的权值
        cin >> u >> v >> w;
        adj[u].push_back({ v, w });  // 从 u 到 v 的边，权值为 w
        adj[v].push_back({ u, w });  // 因为是无向图，从 v 到 u 的边也有，权值为 w
    }

    // d 数组存储每个顶点的最短距离，初始化为 INF（代表不可达）
    vector<int> d(n + 1, INF);
    // vis 数组标记每个顶点是否已经访问过，防止重复访问
    vector<bool> vis(n + 1, 0);

    d[1] = 0;  // 起点 1 到自身的距离为 0

    // 优先队列 pq，存储待处理的顶点和其对应的最短距离
    // 使用 greater<pair<int, int>> 保证队列是按照距离从小到大排序
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.push({ 0, 1 });  // 将起点 1 和距离 0 推入队列

    int res = 0;  // 最小生成树的总权值
    int cnt = 0;  // 最小生成树包含的边数

    // Dijkstra 算法的主体部分，使用优先队列来寻找最短路径
    while (!pq.empty()) {
        // 取出队列中距离最小的顶点
        auto s_d = pq.top().first;  // s_d 是当前顶点的最短距离
        auto u = pq.top().second;  // u 是当前顶点的编号
        pq.pop();  // 弹出队列中的顶点
        if (vis[u]) continue;// 如果顶点 u 已经被访问过，跳过它
        vis[u] = 1;// 标记顶点 u 为已访问
        res += s_d;// 将当前顶点的最短距离 s_d 加到最小生成树的总权值 res 上
        cnt++;// 增加边数
        // 遍历当前顶点 u 的所有邻接边
        for (auto ed : adj[u]) {
            int v = ed.first;  // v 是邻接点
            int w = ed.second; // w 是边 u -> v 的权值
            // 如果 v 没有被访问过，并且通过 u 到 v 的距离比当前已知的距离短，更新最短距离
            if (!vis[v] && w < d[v]) {
                d[v] = w;  // 更新 v 的最短距离
                pq.push({ w, v });  // 将新的距离和顶点 v 推入队列
            }
        }
    }
    // 如果最小生成树包含的边数等于顶点数 - 1，说明图是连通的；否则，图是非连通的
    if (cnt == n - 1)cout << res;  // 输出最小生成树的总权值
    else cout << "orz";  // 如果图不连通，输出 "orz"
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int INF = 0x3f3f3f3f;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    vector<vector<pair<int,int>>> adj(n + 1);
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        // 如果是无向图，记得加反向边
        // adj[v].push_back({u, w});
    }

    int s; // 起点
    cin >> s;
    vector<int> dist(n + 1, INF);
    vector<char> vis(n + 1, 0);
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
    dist[s] = 0;
    pq.push({0, s});

    while (!pq.empty()) {
        auto cur = pq.top(); pq.pop();
        int d = cur.first, u = cur.second;
        if (vis[u]) continue;
        vis[u] = 1;
        // 如果想在弹出时就知道是最终最短距离，使用 vis 标记是安全的
        for (auto ed : adj[u]) {
            int v = ed.first, w = ed.second;
            if (!vis[v] && d + w < dist[v]) {
                dist[v] = d + w;
                pq.push({dist[v], v});
            }
        }
    }

    // 输出：dist[i]（若为 INF 则表示不可达）
    for (int i = 1; i <= n; i++) {
        if (dist[i] == INF) cout << "INF ";
        else cout << dist[i] << ' ';
    }
    cout << '\n';
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int INF = 0x3f3f3f3f;

int heuristic(int u, int goal) {
    // 在具体题目里实现启发函数（必须满足 admissible）
    // 例如在网格上用曼哈顿距离或欧氏距离（取整）等
    return 0; // 默认退化为 Dijkstra
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    vector<vector<pair<int,int>>> adj(n + 1);
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        // 若无向图，加反向边
    }
    int s, t;
    cin >> s >> t;

    vector<int> g(n + 1, INF); // 实际代价 g(x)
    vector<char> closed(n + 1, 0);
    // pq 元素：{ f = g + h, node, g }
    using T = tuple<int,int,int>;
    priority_queue<T, vector<T>, greater<T>> pq;

    g[s] = 0;
    pq.push({heuristic(s, t), s, 0});

    while (!pq.empty()) {
        auto [f, u, gu] = pq.top(); pq.pop();
        if (closed[u]) continue;
        closed[u] = 1;
        if (u == t) {
            cout << gu << '\n'; // 找到目标，gu 即最短距离
            return 0;
        }
        for (auto ed : adj[u]) {
            int v = ed.first, w = ed.second;
            if (closed[v]) continue;
            if (gu + w < g[v]) {
                g[v] = gu + w;
                int fv = g[v] + heuristic(v, t);
                pq.push({fv, v, g[v]});
            }
        }
    }

    // 不可达
    cout << "orz\n";
    return 0;
}