VINMAZE - buggy solution

#include<iostream>
#include<vector>
#include<queue>
#include<utility>
#include<limits.h>
using namespace std;

using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using ANODE = pair<int, int>;
using VANODE = vector<ANODE>;
using VVANODE = vector<VANODE>;
using EDGE = pair<int, ANODE>;

VL dijsktra(vector<VANODE> &adj, int verts, int source) {
    const LL INF = LLONG_MAX;

    VL distances(verts + 1, INF);
    distances[source] = 0;

    using QNODE = pair<LL, int>;
    priority_queue<QNODE, vector<QNODE>, greater<>> pq;
    pq.push({ distances[source], source });

    while (not pq.empty()) {
        auto node = pq.top().second;
        pq.pop();

        if (distances[node] == INF) continue;

        for (auto neigh : adj[node]) {
            auto weight = neigh.second;
            auto vert = neigh.first;
            auto new_dist = distances[node] + weight;

            if (new_dist < distances[vert]) {
                distances[vert] = new_dist;

                QNODE newnode = { distances[vert], vert };
                pq.push(newnode);
            }
        }
    }

    return distances;
}

bool belongs(EDGE &edge, VL &dist_s, VL &dist_t, LL shortest_path_len) {
    int u = edge.first;
    int v = edge.second.first;
    int w = edge.second.second;

    LL sum1 = dist_s[u] + w + dist_t[v];
    LL sum2 = dist_s[v] + w + dist_t[u];

    return sum2 == shortest_path_len or sum1 == shortest_path_len;
}

int main() {
    int n, m; cin >> n >> m;

    vector<EDGE> edges;
    VVANODE adj(n + 1);

    for (int _ = 1; _ <= m; _++) {
        int u, v, w; cin >> u >> v >> w;

        adj[u].push_back({ v, w });
        adj[v].push_back({ u, w });
        edges.push_back({u, {v, w}});
    }

    int s = 1, t = n;
    auto dist_s = dijsktra(adj, n, s);
    auto dist_t = dijsktra(adj, n, t);

    int count = 0;
    for (auto &edge : edges) {
        if (belongs(edge, dist_s, dist_t, dist_s[t])) {
            count += 1;
        }
    }

    cout << count << endl;
    return 0;
}