#include <bits/stdc++.h>

#ifdef ONLINE_JUDGE
#define in std::cin
#define out std::cout
#else
std::ifstream in("state.in");
std::ofstream out("state.out");
#endif

template<typename T, size_t N>
constexpr size_t length_of(T (&)[N]) { return N; }

template<int N, int E, int DE = E>
struct Graph {
    struct ListNode {
        int node;
        int next;
        int edge_data_idx;
    } m_data[E] = {};
    int m_list_start[N] = {};
#ifdef EDGE_COUNT
    int edge_count[N] = {};
#endif
    int m_current_idx = 0;
    int dist[DE];
    int m_current_edge_idx = 0;

    int get_list_start(int u) {
        if (!m_list_start[u]) m_list_start[u] = ++m_current_idx;
        return m_list_start[u];
    }
    void append(int u, int v, int edge_idx) {
#ifdef EDGE_COUNT
        ++edge_count[u];
#endif
        u = get_list_start(u);
        if (!m_data[u].node) {
            m_data[u].node = v;
            m_data[u].edge_data_idx = edge_idx;
            return;
        }
        int tmp = m_data[u].next;
        m_data[u].next = ++m_current_idx;
        m_data[m_current_idx].node = v;
        m_data[m_current_idx].next = tmp;
        m_data[m_current_idx].edge_data_idx = edge_idx;
    }
    void append_bi(int u, int v, int d) {
        append(u, v, m_current_edge_idx);
        append(v, u, m_current_edge_idx);
        dist[m_current_edge_idx++] = d;
    }
    struct Iterator {
        ListNode *m_data;
        int *m_edge_data;
        int m_idx;
        operator bool() {
            return m_data[m_idx].node;
        }
        Iterator &operator++() {
            m_idx = m_data[m_idx].next;
            return *this;
        }
        int edge_data() {
            return m_edge_data[m_data[m_idx].edge_data_idx];
        }
        int operator*() {
            return m_data[m_idx].node;
        }
    };
    Iterator operator[](int u) {
        return Iterator{m_data, dist, get_list_start(u)};
    }
};

constexpr int N = 3e4 + 1, E = 1e5 + 25;
Graph<N, 2 * E, E> g;
std::bitset<N> vis;

int bfs(int x, int y) {
    std::queue<std::pair<int, int>> q{{{x, 0}}};
    vis[x] = 1;
    int ans = 0;
    bool found = 0;
    while (!(q.empty() || found)) {
        auto up = q.front();
        q.pop();
        int u = up.first;
        int ud = up.second;
        for (auto it = g[u]; it; ++it) {
            int v = *it;
            if (vis[v]) continue;
            vis[v] = 1;
            int d = v > u ? it.edge_data() : -it.edge_data();
            if (v == y) return ud + d;
            q.push({v, ud + d});
        }
    }
}

int main() {
    int n, m;
    int x, y;
    in >> n >> m >> x >> y;
    for (int i = 0; i < m; ++i) {
        int u, v, d;
        in >> u >> v >> d;
        g.append_bi(u, v, d);
    }
    out << bfs(x, y) << '\n';
}