Problem p02703 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>
using namespace std;
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
using bll = boost::multiprecision::cpp_int;
using bdouble = boost::multiprecision::cpp_dec_float_100;
using namespace boost::multiprecision;
#endif
#ifdef LOCAL_DEV
void debug_impl() { std::cerr << '\\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \\
  do {                                                                         \\
    std::cerr << "(" << #__VA_ARGS__ << ") =";                                 \\
    debug_impl(__VA_ARGS__);                                                   \\
  } while (false)
#else
#define debug(...)                                                             \\
  do {                                                                         \\
  } while (false)
#endif
#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \\
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  dbool(const dbool &) = default;
  dbool(dbool &&) = default;
  dbool &operator=(const dbool &) = default;
  dbool &operator=(dbool &&) = default;
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::dvector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::dvector<std::dvector<T>> &vv) {
  s << "\\\\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\\n";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\\t" << (*itr).first << " : " << (*itr).second << "\\n";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
// #define int long long
using ll = long long;
// constexpr int INF = 1e9;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18; //(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1LL, 0LL, -1LL, 0LL};
constexpr ll dy[4] = {0LL, 1LL, 0LL, -1LL};
constexpr ll dx8[8] = {1LL, 0LL, -1LL, 0LL, 1LL, 1LL, -1LL, -1LL};
constexpr ll dy8[8] = {0LL, 1LL, 0LL, -1LL, 1LL, -1LL, 1LL, -1LL};
#define rep(i, n) for (ll i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (ll i = 1, i##_length = (n); i <= i##_length; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrepeq(i, n) for (ll i = (n); i >= 1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\\n'; }
template <typename Head, typename... Tail> void p(Head head, Tail... tail) {
  std::cout << head << (sizeof...(tail) ? " " : "");
  p(tail...);
}
template <typename T> inline void pv(std::vector<T> &v) {
  for (ll i = 0, N = v.size(); i < N; i++)
    std::cout << v[i] << " \\n"[i == N - 1];
}
template <typename T> inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <typename T> inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
template <typename T> inline void uniq(std::vector<T> &v) {
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

/*-----8<-----template-----8<-----*/

class Edge {
public:
  ll from, to, cost;
  Edge() {}
  Edge(ll from, ll to, ll cost) : from(from), to(to), cost(cost) {}
};
ostream &operator<<(ostream &s, const Edge &e) {
  s << "{ " << e.from << " -> " << e.to << ", " << e.cost << " }";
  return s;
}

/*
計算量：O(ElogV)
引数
　g:探索するグラフ
　start:探索するスタートノード番号
戻り値
　dist:スタートノードから各頂点までの距離
　prev:最短路木の親頂点
*/
void dijkstra(const vector<vector<Edge>> &g, ll start, vector<ll> &dist,
              vector<ll> &prev) {
  ll gsize = g.size();
  dist.assign(gsize, INF);
  dist[start] = 0;
  prev.assign(gsize, -1);

  priority_queue<Edge, vector<Edge>, function<bool(Edge, Edge)>> que(
      [](const Edge &x, const Edge &y) {
        return x.cost != y.cost
                   ? (x.cost > y.cost)
                   : (x.from != y.from ? x.from < y.from : x.to < y.to);
      });
  que.push(Edge(-1, start, 0));
  while (!que.empty()) {
    Edge e = que.top();
    que.pop();
    if (prev[e.to] != -1)
      continue;
    prev[e.to] = e.from;
    for (Edge f : g[e.to]) {
      if (dist[f.to] > e.cost + f.cost) {
        dist[f.to] = e.cost + f.cost;
        que.push(Edge(f.from, f.to, e.cost + f.cost));
      }
    }
  }
}
// 最短路木の親頂点を元にstart->goalの経路を作成
vector<ll> buildPath(const vector<ll> &prev, ll goal) {
  vector<ll> path;
  for (ll u = goal; u >= 0; u = prev[u])
    path.push_back(u);
  reverse(path.begin(), path.end());
  return path;
}

/*-----8<-----library-----8<-----*/

constexpr ll N_MAX = 50;
constexpr ll M_MAX = 100;
constexpr ll S_MAX = 1e9;
constexpr ll A_I_MAX = 50;
constexpr ll B_I_MAX = 1e9;
constexpr ll C_I_MAX = 1e9;
constexpr ll D_I_MAX = 1e9;

ll N, M, S;
vector<ll> U;
vector<ll> V;
vector<ll> A;
vector<ll> B;
vector<ll> C;
vector<ll> D;

void solve() {
  scanf("%lld%lld%lld", &N, &M, &S);
  U.assign(M, 0);
  V.assign(M, 0);
  A.assign(M, 0);
  B.assign(M, 0);
  rep(i, M) {
    scanf("%lld%lld%lld%lld", &U[i], &V[i], &A[i], &B[i]);
    U[i]--;
    V[i]--;
  }
  C.assign(N, 0);
  D.assign(N, 0);
  rep(i, N) { scanf("%lld%lld", &C[i], &D[i]); }

  ll coinsize = 2501;
  if (S >= coinsize)
    S = coinsize - 1;
  vector<vector<Edge>> g(N * coinsize);
  // 銀貨を捨てる
  rep(i, N) {
    rep(j, coinsize - 1) {
      g[i * coinsize + j + 1].emplace_back(i * coinsize + j + 1,
                                           i * coinsize + j, 0);
    }
  }
  // 銀貨を交換
  rep(i, N) {
    rep(j, coinsize) {
      if (j + C[i] >= coinsize)
        break;
      g[i * coinsize + j].emplace_back(i * coinsize + j,
                                       i * coinsize + j + C[i], D[i]);
    }
  }
  // 電車に乗る
  rep(i, M) {
    rrep(j, coinsize) {
      if (j - A[i] < 0)
        break;
      g[U[i] * coinsize + j].emplace_back(U[i] * coinsize + j,
                                          V[i] * coinsize + j - A[i], B[i]);
      g[V[i] * coinsize + j].emplace_back(V[i] * coinsize + j,
                                          U[i] * coinsize + j - A[i], B[i]);
    }
  }

  vector<ll> dist, prev;
  dijkstra(g, 0 + S, dist, prev);
  debug(dist);

  repeq(i, N - 1) p(dist[i * coinsize]);
}

// https://atcoder.jp/contests/abc164/tasks/abc164_e
signed main() {
  solve();
  return 0;
}


Error: TLE

Fixed submission:

#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
using bll = boost::multiprecision::cpp_int;
using bdouble = boost::multiprecision::cpp_dec_float_100;
using namespace boost::multiprecision;
#endif
#if __has_include(<boost/stacktrace.hpp>)
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \\
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
#endif
#ifdef LOCAL_TEST
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
#endif
#ifdef LOCAL_DEV
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\\n";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\\t" << (*itr).first << " : " << (*itr).second << "\\n";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
void debug_impl() { std::cerr << '\\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \\
  do {                                                                         \\
    std::cerr << "(" << #__VA_ARGS__ << ") =";                                 \\
    debug_impl(__VA_ARGS__);                                                   \\
  } while (false)
#else
#define debug(...)                                                             \\
  do {                                                                         \\
  } while (false)
#endif
// #define int long long
using ll = long long;
// constexpr int INF = 1e9;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18; //(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
#define rep(i, n) for (ll i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (ll i = 1, i##_length = (n); i <= i##_length; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrepeq(i, n) for (ll i = (n); i >= 1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\\n'; }
template <typename Head, typename... Tail> void p(Head head, Tail... tail) {
  std::cout << head << (sizeof...(tail) ? " " : "");
  p(tail...);
}
template <typename T> inline void pv(std::vector<T> &v) {
  for (ll i = 0, N = v.size(); i < N; i++)
    std::cout << v[i] << " \\n"[i == N - 1];
}
template <typename T> inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <typename T> inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
template <typename T> inline void uniq(std::vector<T> &v) {
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

/*-----8<-----template-----8<-----*/

class Edge {
public:
  ll from, to, cost;
  Edge() {}
  Edge(ll from, ll to, ll cost) : from(from), to(to), cost(cost) {}
};
ostream &operator<<(ostream &s, const Edge &e) {
  s << "{ " << e.from << " -> " << e.to << ", " << e.cost << " }";
  return s;
}

/*
計算量：O(ElogV)
引数
　g:探索するグラフ
　start:探索するスタートノード番号
戻り値
　dist:スタートノードから各頂点までの距離
　prev:最短路木の親頂点
*/
void dijkstra(const vector<vector<Edge>> &g, ll start, vector<ll> &dist,
              vector<ll> &prev) {
  ll gsize = g.size();
  dist.assign(gsize, INF);
  dist[start] = 0;
  prev.assign(gsize, -1);

  priority_queue<Edge, vector<Edge>, function<bool(Edge, Edge)>> que(
      [](const Edge &x, const Edge &y) {
        return x.cost != y.cost
                   ? (x.cost > y.cost)
                   : (x.from != y.from ? x.from < y.from : x.to < y.to);
      });
  que.push(Edge(-1, start, 0));
  while (!que.empty()) {
    Edge e = que.top();
    que.pop();
    if (prev[e.to] != -1)
      continue;
    prev[e.to] = e.from;
    for (Edge f : g[e.to]) {
      if (dist[f.to] > e.cost + f.cost) {
        dist[f.to] = e.cost + f.cost;
        que.push(Edge(f.from, f.to, e.cost + f.cost));
      }
    }
  }
}
// 最短路木の親頂点を元にstart->goalの経路を作成
vector<ll> buildPath(const vector<ll> &prev, ll goal) {
  vector<ll> path;
  for (ll u = goal; u >= 0; u = prev[u])
    path.push_back(u);
  reverse(path.begin(), path.end());
  return path;
}

/*-----8<-----library-----8<-----*/

constexpr ll N_MAX = 50;
constexpr ll M_MAX = 100;
constexpr ll S_MAX = 1e9;
constexpr ll A_I_MAX = 50;
constexpr ll B_I_MAX = 1e9;
constexpr ll C_I_MAX = 1e9;
constexpr ll D_I_MAX = 1e9;

ll N, M, S;
vector<ll> U;
vector<ll> V;
vector<ll> A;
vector<ll> B;
vector<ll> C;
vector<ll> D;

void solve() {
  scanf("%lld%lld%lld", &N, &M, &S);
  U.assign(M, 0);
  V.assign(M, 0);
  A.assign(M, 0);
  B.assign(M, 0);
  rep(i, M) {
    scanf("%lld%lld%lld%lld", &U[i], &V[i], &A[i], &B[i]);
    U[i]--;
    V[i]--;
  }
  C.assign(N, 0);
  D.assign(N, 0);
  rep(i, N) { scanf("%lld%lld", &C[i], &D[i]); }

  ll coinsize = 2501;
  if (S >= coinsize)
    S = coinsize - 1;
  vector<vector<Edge>> g(N * coinsize);
  // 銀貨を捨てる
  rep(i, N) {
    rep(j, coinsize - 1) {
      g[i * coinsize + j + 1].emplace_back(i * coinsize + j + 1,
                                           i * coinsize + j, 0);
    }
  }
  // 銀貨を交換
  rep(i, N) {
    rep(j, coinsize) {
      if (j + C[i] >= coinsize)
        break;
      g[i * coinsize + j].emplace_back(i * coinsize + j,
                                       i * coinsize + j + C[i], D[i]);
    }
  }
  // 電車に乗る
  rep(i, M) {
    rrep(j, coinsize) {
      if (j - A[i] < 0)
        break;
      g[U[i] * coinsize + j].emplace_back(U[i] * coinsize + j,
                                          V[i] * coinsize + j - A[i], B[i]);
      g[V[i] * coinsize + j].emplace_back(V[i] * coinsize + j,
                                          U[i] * coinsize + j - A[i], B[i]);
    }
  }

  vector<ll> dist, prev;
  dijkstra(g, 0 + S, dist, prev);
  debug(dist);

  repeq(i, N - 1) p(dist[i * coinsize]);
}

// https://atcoder.jp/contests/abc164/tasks/abc164_e
signed main() {
  solve();
  return 0;
}