Language: C++

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

#define fs first
#define sc second
#define pb emplace_back
#define mp make_pair
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()

const int32_t inf = 1001001001;
const int64_t infll = 1001001001001001001ll;
const int dx[] = {0, -1, 1, 0, -1, 1, -1, 1}, dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};

template <typename T> using vector2d = vector<vector<T>>;

// clang-format off
template <typename T> void sort(vector<T> &v) { sort(all(v)); }
// ostream &operator<<(ostream &os, __int128_t value) { if (ostream::sentry(os)) { __uint128_t tmp = value < 0 ?-value : value; char buffer[64]; char *d = end(buffer); do { --d; *d = "0123456789"[tmp % 10]; tmp /= 10; } while(tmp != 0); if (value < 0) { --d; *d = '-'; } int len = end(buffer) - d; if (os.rdbuf()->sputn(d, len) != len) {os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __int128_t &value) { string in; is >> in; value = 0; for (const char &c : in) {if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } if (in[0] == '-') value *= -1; return is; }
// ostream &operator<<(ostream &os, __uint128_t value) { if (ostream::sentry(os)) { char buffer[64]; char *d =end(buffer); do { --d; *d = "0123456789"[value % 10]; value /= 10; } while (value != 0); int len = end(buffer) - d;if (os.rdbuf()->sputn(d, len) != len) { os.setstate(ios_base::badbit); }} return os; }
// istream &operator>>(istream &is, __uint128_t &value) { string in; is >> in; value = 0; for (const char &c : in) {if ('0' <= c && c <= '9') value = 10 * value + (c - '0'); } return is; }
template <typename T> ostream&operator<<(ostream &os, vector<T> &v) { os << v[0]; for (int i = 1; i < v.size(); ++i) os << " " << v[i]; return os;}
template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << p.fs << " " << p.sc;return os; } template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.fs >>p.sc; return is; }

struct IoSetup { IoSetup(){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(10); cerr << fixed <<
setprecision(10); } } iosetup;

inline int64_t in() { int64_t x = 0; cin >> x; return x; }
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
// clang-format on

const int mod = 1e9 + 7;

struct edge {
  edge(int to, int64_t cost) : to(to), cost(cost) {}
  int to;
  int64_t cost;
};

vector<int> used;
vector2d<edge> rG, nG;

struct Dijkstra {
  Dijkstra(int V) : V(V), G(V) {}

  using P = pair<int64_t, int>;
  const int64_t inf = 1001001001001001001ll;

  int V;
  vector<vector<edge>> G;
  vector<int64_t> d;

  void init(int n) {
    V = n;
    G.resize(n);
  }

  void debug() {
    cerr << "edges : " << endl;
    for (int i = 0; i < V; ++i)
      for (auto e : nG[i]) cerr << i << " -> " << e.to << " : " << e.cost << endl;
    cerr << endl << "dist : " << endl;
    for (int i = 0; i < V; ++i) cerr << i << " : " << d[i] << endl;
  }

  void add_edge(int u, int v, int64_t c) {
    G[u].push_back(edge(v, c));
    G[v].push_back(edge(u, c));
  }

  void nGadd_edge(int u, int v, int64_t c) {
    nG[u].push_back(edge(v, c));
    rG[v].push_back(edge(u, c));
  }

  void build(int s) {
    d.assign(V, inf);
    priority_queue<P, vector<P>, greater<P>> q;

    d[s] = 0;
    q.push(P(0ll, s));

    while (!q.empty()) {
      P p = q.top();
      q.pop();
      int v = p.second;
      if (d[v] < p.first) continue;
      for (auto &e : G[v]) {
        if (d[e.to] == p.first + e.cost) {
          nGadd_edge(v, e.to, e.cost);
        } else if (d[e.to] > p.first + e.cost) {
          d[e.to] = p.first + e.cost;
          q.push(P(d[e.to], e.to));
          nG[e.to].clear();
          nGadd_edge(v, e.to, e.cost);
        }
      }
    }
  }

  int64_t operator[](int v) {
    return d[v];
  }
};

void dfs(int v) {
  if (used[v]) return;
  // cerr << v << endl;
  used[v] = 1;
  for (auto &e : rG[v]) {
    dfs(e.to);
  }
}

signed main(int32_t argc, char *argv[]) {
  int n = in(), m = in();
  int s = in() - 1, t = in() - 1;
  nG.resize(n);
  rG.resize(n);

  Dijkstra g(n);
  for (int i = 0; i < m; ++i) {
    int u = in() - 1, v = in() - 1, d = 2 * in();
    g.add_edge(u, v, d);
  }

  g.build(s);
  // g.debug();

  int64_t d = g[t] / 2, ans = 0;
  vector<pair<int, int>> idxs, idxt;

  used.resize(n);
  dfs(t);

  for (int i = 0; i < n; ++i) {
    if (used[i]) {
      idxs.pb(g[i], i);
      idxt.pb(g[t] - g[i], i);
    }
  }

  sort(all(idxs));
  sort(all(idxt));

  vector<int64_t> dps(n), dpt(n);
  dps[s] = 1;
  dpt[t] = 1;
  for (int i = 0; i < idxt.size(); ++i) {
    int v = idxt[i].sc;
    for (auto &e : rG[v]) {
      dpt[e.to] += dpt[v];
      dpt[e.to] %= mod;
    }
  }
  for (int i = 0; i < idxs.size(); ++i) {
    int v = idxs[i].sc;
    for (auto &e : nG[v]) {
      dps[e.to] += dps[v];
      dps[e.to] %= mod;
    }
  }

  int64_t ans = dps[t] * dps[t];
  int64_t uku = 0;
  for (int i = 0; i < idxs.size(); ++i) {
    int v = idxs[i].sc;
    if (g[v] == d) {
      int64_t beet = dps[v] * dpt[v] % mod;
      uku += beet * beet % mod;
      uku %= mod;
    }
    for (auto e : nG[v]) {
      if (g[v] < d && d < g[e.to]) {
        int64_t beet = dps[v] * dpt[e.to] % mod;
        uku += beet * beet % mod;
        uku %= mod;
      }
    }
  }

  // while (!pq.empty()) {
  //   pair<int, int> p = pq.top();
  //   pq.pop();
  //
  //   int v = p.second;
  //   for (auto &e : nG[v]) {
  //     dp[e.to] += dp[v];
  //     dp[e.to] %= mod;
  //     if (g[v] < d / 2 && g[e.to] >= d / 2 && used[e.to]) {
  //       ans -= dp[v];
  //       // cerr << v << endl;
  //     }
  //     pq.push(mp(g[e.to], e.to));
  //   }
  // }
  // cerr << "dp : " << dp << endl;
  // cerr << ans << endl;
  // cerr << "dp[t] = " << dp[t] << endl;

  ans = ((dps[t] * dps[t]) % mod + mod - ans) % mod;
  cout << ans << endl;
}


Compiler output:
a.cc: In function 'int main(int32_t, char**)':
a.cc:166:11: error: redeclaration of 'int64_t ans'
  166 |   int64_t ans = dps[t] * dps[t];
      |           ^~~
a.cc:132:25: note: 'int64_t ans' previously declared here
  132 |   int64_t d = g[t] / 2, ans = 0;
      |                         ^~~