Problem p02576 (C++) — buggy submission, verdict: Runtime Error

#pragma region Macros
#pragma GCC optimize("O3")
#pragma GCC target("avx2,avx")
#pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>

#define ll long long
#define ld long double
#define i128 __int128_t
#define ull unsigned long long int

#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rep2(i, a, b) for (ll i = a; i <= b; ++i)
#define rep3(i, a, b) for (ll i = a; i >= b; --i)

#define pii pair<int, int>
#define pll pair<ll, ll>

#define vi vector<int>
#define vll vector<ll>
#define vpi vector<pii>
#define vpll vector<pll>

#define pb push_back
#define eb emplace_back

#define fi first
#define se second
#define all(c) begin(c), end(c)

#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))

#define overload2(_1, _2, name, ...) name
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size)                                                  \\
  vector<type> name(size);                                                     \\
  IN(name)
#define vv(type, name, h, ...)                                                 \\
  vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, w)                                                   \\
  vector<vector<type>> name(h, vector<type>(w));                               \\
  IN(name)
#define vvv(type, name, h, w, ...)                                             \\
  vector<vector<vector<type>>> name(                                           \\
      h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)                                         \\
  vector<vector<vector<vector<type>>>> name(                                   \\
      a, vector<vector<vector<type>>>(                                         \\
             b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))

#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

using namespace std;
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
#define si(c) (int)(c).size()
#define INT(...)                                                               \\
  int __VA_ARGS__;                                                             \\
  IN(__VA_ARGS__)
#define LL(...)                                                                \\
  ll __VA_ARGS__;                                                              \\
  IN(__VA_ARGS__)
#define ULL(...)                                                               \\
  ull __VA_ARGS__;                                                             \\
  IN(__VA_ARGS__)
#define STR(...)                                                               \\
  string __VA_ARGS__;                                                          \\
  IN(__VA_ARGS__)
#define CHR(...)                                                               \\
  char __VA_ARGS__;                                                            \\
  IN(__VA_ARGS__)
#define DBL(...)                                                               \\
  double __VA_ARGS__;                                                          \\
  IN(__VA_ARGS__)
#define LD(...)                                                                \\
  ld __VA_ARGS__;                                                              \\
  IN(__VA_ARGS__)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T> void scan(vector<T> &);
template <class T> void scan(vector<T> &a) {
  for (auto &i : a)
    scan(i);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &...tail) {
  scan(head);
  IN(tail...);
}
string stin() {
  string s;
  cin >> s;
  return s;
}
template <class T, class S> inline bool chmax(T &a, S b) {

  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T, class S> inline bool chmin(T &a, S b) {

  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
vi iota(int n) {
  vi a(n);
  iota(all(a), 0);
  return a;
}
template <class T> void UNIQUE(vector<T> &x) {
  sort(all(x));
  x.erase(unique(all(x)), x.end());
}
int in() {
  int x;
  cin >> x;
  return x;
}
ll lin() {
  unsigned long long x;
  cin >> x;
  return x;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string &a) { cout << a; }
void print(double a) { cout << a; }
template <class T> void print(const vector<T> &);
template <class T, size_t size> void print(const array<T, size> &);
template <class T, class L> void print(const pair<T, L> &p);
template <class T, size_t size> void print(const T (&)[size]);
template <class T> void print(const vector<T> &a) {

  if (a.empty())
    return;
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
  cout << endl;
}
template <class T> void print(const deque<T> &a) {

  if (a.empty())
    return;
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
}
template <class T, size_t size> void print(const array<T, size> &a) {
  print(a[0]);
  for (auto i = a.begin(); ++i != a.end();) {
    cout << " ";
    print(*i);
  }
}
template <class T, class L> void print(const pair<T, L> &p) {
  cout << '(';
  print(p.first);
  cout << ",";
  print(p.second);
  cout << ')';
}
template <class T> void print(set<T> &x) {
  for (auto e : x)
    print(e), cout << " ";
  cout << endl;
}
template <class T> void print(multiset<T> &x) {
  for (auto e : x)
    print(e), cout << " ";
  cout << endl;
}
template <class T, size_t size> void print(const T (&a)[size]) {
  print(a[0]);
  for (auto i = a; ++i != end(a);) {
    cout << " ";
    print(*i);
  }
}
template <class T> void print(const T &a) { cout << a; }
int out() {
  putchar('\\n');
  return 0;
}
template <class T> int out(const T &t) {
  print(t);
  putchar('\\n');
  return 0;
}
template <class Head, class... Tail>
int out(const Head &head, const Tail &...tail) {
  print(head);
  putchar(' ');
  out(tail...);
  return 0;
}
ll gcd(ll a, ll b) {
  while (b) {
    ll c = b;
    b = a % b;
    a = c;
  }
  return a;
}
ll lcm(ll a, ll b) {

  if (!a || !b)
    return 0;
  return a * b / gcd(a, b);
}
vector<pll> factor(ll x) {
  vector<pll> ans;
  for (ll i = 2; i * i <= x; i++)

    if (x % i == 0) {
      ans.push_back({i, 1});
      while ((x /= i) % i == 0)
        ans.back().second++;
    }

  if (x != 1)
    ans.push_back({x, 1});
  return ans;
}
template <class T> vector<T> divisor(T x) {
  vector<T> ans;
  for (T i = 1; i * i <= x; i++)

    if (x % i == 0) {
      ans.pb(i);

      if (i * i != x)
        ans.pb(x / i);
    }
  return ans;
}
template <typename T> void zip(vector<T> &x) {
  vector<T> y = x;
  sort(all(y));
  for (int i = 0; i < x.size(); ++i) {
    x[i] = lb(y, x[i]);
  }
}
int popcount(ll x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n - 1)(rng); }
ll rndll(ll n) { return uniform_int_distribution<ll>(0, n - 1)(rng); }
template <typename T> void shuffle(vector<T> &v) {
  rep3(i, v.size() - 1, 1) { swap(v[i], v[rnd(i)]); }
}
#define endl '\\n'
vector<string> YES{"NO", "YES"};
vector<string> Yes{"No", "Yes"};
vector<string> yes{"no", "yes"};

#ifdef _LOCAL
#undef endl
#define debug(x)                                                               \\
  cout << #x << ": ";                                                          \\
  print(x);                                                                    \\
  cout << endl;
void err() {}
template <class T> void err(const T &t) {
  print(t);
  cout << " ";
}
template <class Head, class... Tail>
void err(const Head &head, const Tail &...tail) {
  print(head);
  putchar(' ');
  out(tail...);
}
#else
#define debug(x)
template <class... T> void err(const T &...) {}
#endif

template <typename T> struct edge {
  int from, to;
  T cost;
  int id;
  edge(int to, T cost) : from(-1), to(to), cost(cost) {}
  edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
  edge(int from, int to, T cost, int id)
      : from(from), to(to), cost(cost), id(id) {}
  edge &operator=(const int &x) {
    to = x;
    return *this;
  }
  operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;

struct Graph : vector<vector<int>> {
  using vector<vector<int>>::vector;
  Graph(int n, int m) : vector(n) { read(m); }
  inline void add(int a, int b, bool directed = false) {
    (*this)[a].emplace_back(b);

    if (!directed)
      (*this)[b].emplace_back(a);
  }
  void read(int n = -1, int offset = 1, bool directed = false) {

    if (n == -1)
      n = this->size() - 1;
    int a, b;
    while (n--) {
      cin >> a >> b;
      Graph::add(a - offset, b - offset, directed);
    }
  }
};
template <typename T> struct WeightedGraph : vector<Edges<T>> {
  using vector<Edges<T>>::vector;
  inline void add(int a, int b, T c, bool directed = false) {
    (*this)[a].emplace_back(b, c);

    if (!directed)
      (*this)[b].emplace_back(a, c);
  }
  void read(int n = -1, int offset = 1) {

    if (n == -1)
      n = this->size() - 1;
    int a, b;
    T c;
    while (n--) {
      cin >> a >> b >> c;
      WeightedGraph::add(a - offset, b - offset, c);
    }
  }
};
struct Setup_io {
  Setup_io() {
    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(15);
  }
} setup_io;

#pragma endregion

// _________コーディングはここから！！___________

main() {
  INT(n, x, t);
  cout << ((n + x - 1) / x) * t << endl;
}


Error: -11

Fixed submission:

#include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (long long)(n); ++i)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}

const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const double pi = acos(-1);
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, -1, 1, 1, -1};
int ddx[5] = {2, 1, 0, -1, -2};
int ddy[5] = {2, 1, 0, -1, -2};

const int MAX = 510000;

int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  int h, w;
  cin >> h >> w;

  int sy, sx;
  cin >> sy >> sx;
  sy--;
  sx--;

  int gy, gx;
  cin >> gy >> gx;
  gy--;
  gx--;

  vector<string> vec(h);
  rep(i, h) cin >> vec[i];

  queue<P> que;
  que.push(P(sy, sx));
  vector<vector<ll>> d(h, vector<ll>(w, 1e8));
  d[sy][sx] = 0;
  while (!que.empty()) {
    int y = que.front().first;
    int x = que.front().second;
    que.pop();
    rep(i, 4) {
      int ny = y + dy[i];
      int nx = x + dx[i];
      if (ny < 0 || h <= ny || nx < 0 || w <= nx)
        continue;
      if (vec[ny][nx] == '#')
        continue;
      if (d[ny][nx] <= d[y][x])
        continue;
      if (ny == gy && nx == gx) {
        d[ny][nx] = d[y][x];
        break;
      }
      d[ny][nx] = d[y][x];
      que.push(P(ny, nx));
    }
    rep(i, 5) rep(j, 5) {
      int ny = y + ddy[i];
      int nx = x + ddx[j];
      if (i == 2 && j == 2)
        continue;
      if (ny < 0 || h <= ny || nx < 0 || w <= nx)
        continue;
      if (vec[ny][nx] == '#')
        continue;
      if (d[ny][nx] <= d[y][x] + 1)
        continue;
      d[ny][nx] = d[y][x] + 1;
      que.push(P(ny, nx));
    }
  }
  if (d[gy][gx] == 1e8)
    cout << -1 << endl;
  else
    cout << d[gy][gx] << endl;

  return 0;
}