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

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;

// common
typedef int i32;
typedef long long i64, ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef long long ll;
typedef vector<long long> vl;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpll;
typedef vector<string> vs;
typedef long double ld;

#define BR "\\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))

// config
// #undef NDEBUG
// #define INF 1<<30
// #define EPS 1e-8
// const ll MOD =100000007;

// debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp, act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act)                                                        \\
  if (exp != act) {                                                            \\
    DUMPLN(exp);                                                               \\
    DEBUGLN(act);                                                              \\
  }
#define STOP(e)                                                                \\
  CHECK(e, true);                                                              \\
  if (!(e))                                                                    \\
    exit(1);
#endif

template <class T> inline string toString(const vector<T> &x) {
  stringstream ss;
  REP(i, x.size()) {
    if (i != 0)
      ss << " ";
    ss << x[i];
  }
  return ss.str();
}

template <class T> inline string toString(const vector<vector<T>> &map) {
  stringstream ss;
  REP(i, map.size()) {
    if (i != 0)
      ss << BR;
    ss << toString(map[i]);
  }
  return ss.str();
}
template <class K, class V> string toString(map<K, V> &x) {
  string res;
  stringstream ss;
  for (auto &p : x)
    ss << p.first << ":" << p.second << " ";
  return ss.str();
}

string BITtoString(int bit) {
  stringstream ss;
  while (bit != 0) {
    ss << (bit % 2);
    bit /= 2;
  }
  string res = ss.str();
  reverse(ALL(res));
  return res;
}

template <typename T, typename V> inline T mod(T v, V MOD) {
  return (v % MOD + MOD) % MOD;
}

namespace ShortestPath {
const int INF = 1 << 28;
struct Edge {
  int from, to, cost;
  Edge(int from, int to, int cost) : from(from), to(to), cost(cost){};
};
ostream &operator<<(ostream &os, const Edge &e) {
  os << "(" << e.from << "->" << e.to << ")";
  return os;
}
struct Task {
  int prev, pos, cost;
  Task(int prev, int pos, int cost) : prev(prev), pos(pos), cost(cost){};
  bool operator>(const Task &r) const { return cost > r.cost; }
};
typedef vector<vector<Edge>> Graph;
typedef vector<vector<int>> Mat;

// verified by codoforces 144D
// http://codeforces.com/contest/144/submission/4976825
//  // 負の辺がない
//  // O(E*logV)
vector<int> dijkstra(const Graph &g, const int s, vector<int> &prev) {
  const int V = g.size();
  vector<int> d(V, INF);
  d[s] = 0;
  fill(ALL(prev), -2);
  priority_queue<Task, vector<Task>, greater<Task>> que;
  que.push(Task(-1, s, 0));
  while (!que.empty()) {
    Task task = que.top();
    que.pop();
    // if(prev[task.pos]!=-2)continue;
    if (d[task.pos] < task.cost)
      continue;
    prev[task.pos] = task.prev;
    EACH(e, g[task.pos]) {
      if (d[e->to] > d[e->from] + e->cost) {
        d[e->to] = d[e->from] + e->cost;
        que.push(Task(e->from, e->to, d[e->to]));
      }
    }
  }
  return d;
}
vector<int> dijkstra(const Graph &g, const int s) {
  vector<int> prev(g.size());
  return dijkstra(g, s, prev);
}

} // namespace ShortestPath
using namespace ShortestPath;

class Main {
public:
  int sx, sy, gx, gy;
  int n;
  int lx, ly;

  int enc(int x, int y, int t) {
    return t + 6 * ((x + lx) + (2 * lx + 1) * (y + ly));
  }

  void run() {
    cin >> sx >> sy >> gx >> gy;
    cin >> n;
    vector<int> xs(n), ys(n);
    REP(i, n) cin >> xs[i] >> ys[i];
    cin >> lx >> ly;

    vector<vector<bool>> block(2 * ly + 1, vector<bool>(2 * lx + 1));
    REP(i, n) { block[ys[i] + ly][xs[i] + lx] = true; }

    vector<vector<Edge>> es(6 * (2 * lx + 1) * (2 * ly + 1));
    // set<int> hash;
    REP(t, 6) {
      for (int y = -ly; y <= ly; y++) {
        for (int x = -lx; x <= lx; x++) {
          // if(hash.count(enc(x,y,t)))
          // 	DUMP(enc(x,y,t));
          // else
          // 	hash.insert(enc(x,y,t));
          // stop
          es[enc(x, y, t)].push_back(
              Edge(enc(x, y, t), enc(x, y, (t + 1) % 6), 1));

          // move
          int oneesandir = abs(x * y * t) % 6;
          REP(dir, 6) {
            int nx = dir % 3 == 0 ? x : (dir / 3) == 0 ? x + 1 : x - 1;
            int ny = x % 2 == 0 ? (dir == 0                 ? y + 1
                                   : (dir == 1 || dir == 5) ? y
                                                            : y - 1)
                                : (dir == 3                 ? y - 1
                                   : (dir == 2 || dir == 4) ? y
                                                            : y + 1);

            if (!IN(-lx, nx, lx + 1) || !IN(-ly, ny, ly + 1))
              continue;
            if (block[ny + ly][nx + lx])
              continue;

            es[enc(x, y, t)].push_back(Edge(enc(x, y, t),
                                            enc(nx, ny, (t + 1) % 6),
                                            dir != oneesandir ? 1 : 0));
          }
        }
      }
    }
    vector<int> res = dijkstra(es, enc(sx, sy, 0));

    int mv = INF;
    REP(t, 6) mv = min(mv, res[enc(gx, gy, t)]);

    cout << (mv != INF ? mv : -1) << endl;
  }
};

int main() {
  ios::sync_with_stdio(false);
  Main().run();
  return 0;
}

Error: -11

Fixed submission:

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;

// common
typedef int i32;
typedef long long i64, ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vpii;
typedef long long ll;
typedef vector<long long> vl;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpll;
typedef vector<string> vs;
typedef long double ld;

#define BR "\\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))

// config
// #undef NDEBUG
// #define INF 1<<30
// #define EPS 1e-8
// const ll MOD =100000007;

// debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp, act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act)                                                        \\
  if (exp != act) {                                                            \\
    DUMPLN(exp);                                                               \\
    DEBUGLN(act);                                                              \\
  }
#define STOP(e)                                                                \\
  CHECK(e, true);                                                              \\
  if (!(e))                                                                    \\
    exit(1);
#endif

template <class T> inline string toString(const vector<T> &x) {
  stringstream ss;
  REP(i, x.size()) {
    if (i != 0)
      ss << " ";
    ss << x[i];
  }
  return ss.str();
}

template <class T> inline string toString(const vector<vector<T>> &map) {
  stringstream ss;
  REP(i, map.size()) {
    if (i != 0)
      ss << BR;
    ss << toString(map[i]);
  }
  return ss.str();
}
template <class K, class V> string toString(map<K, V> &x) {
  string res;
  stringstream ss;
  for (auto &p : x)
    ss << p.first << ":" << p.second << " ";
  return ss.str();
}

string BITtoString(int bit) {
  stringstream ss;
  while (bit != 0) {
    ss << (bit % 2);
    bit /= 2;
  }
  string res = ss.str();
  reverse(ALL(res));
  return res;
}

template <typename T, typename V> inline T mod(T v, V MOD) {
  return (v % MOD + MOD) % MOD;
}

namespace ShortestPath {
const int INF = 1 << 28;
struct Edge {
  int from, to, cost;
  Edge(int from, int to, int cost) : from(from), to(to), cost(cost){};
};
ostream &operator<<(ostream &os, const Edge &e) {
  os << "(" << e.from << "->" << e.to << ")";
  return os;
}
struct Task {
  int prev, pos, cost;
  Task(int prev, int pos, int cost) : prev(prev), pos(pos), cost(cost){};
  bool operator>(const Task &r) const { return cost > r.cost; }
};
typedef vector<vector<Edge>> Graph;
typedef vector<vector<int>> Mat;

// 最大も可
// 負の閉路が判定可能
// O(V*E)
vector<int> bellmanFord(Graph g, int s, vector<int> prev) {
  const int V = g.size();
  vector<int> d(V, INF);
  d[s] = 0;
  fill(ALL(prev), -2);
  REP(k, V) {
    REP(i, V) REP(j, g[i].size()) {
      Edge e = g[i][j];
      if (d[e.to] > d[e.from] + e.cost) {
        d[e.to] = d[e.from] + e.cost;
        prev[e.to] = e.from;
        if (k == V - 1)
          d[e.to] = -INF;
      }
    }
  }
  return d;
}

// verified by codoforces 144D
// http://codeforces.com/contest/144/submission/4976825
//  // 負の辺がない
//  // O(E*logV)
vector<int> dijkstra(const Graph &g, const int s, vector<int> &prev) {
  const int V = g.size();
  vector<int> d(V, INF);
  d[s] = 0;
  fill(ALL(prev), -2);
  priority_queue<Task, vector<Task>, greater<Task>> que;
  que.push(Task(-1, s, 0));
  while (!que.empty()) {
    Task task = que.top();
    que.pop();
    // if(prev[task.pos]!=-2)continue;
    if (d[task.pos] < task.cost)
      continue;
    prev[task.pos] = task.prev;
    EACH(e, g[task.pos]) {
      if (d[e->to] > d[e->from] + e->cost) {
        d[e->to] = d[e->from] + e->cost;
        que.push(Task(e->from, e->to, d[e->to]));
      }
    }
  }
  return d;
}
vector<int> dijkstra(const Graph &g, const int s) {
  vector<int> prev(g.size());
  return dijkstra(g, s, prev);
}

// O(n^3) n≦100
void warshall_floyd(Mat &d, Mat &prev) {
  const int V = d.size();
  REP(k, V)
  REP(i, V) REP(j, V) {
    if (d[i][j] > d[i][k] + d[k][j]) {
      d[i][j] = d[i][k] + d[k][j];
      prev[i][j] = k;
    }
  }
}
} // namespace ShortestPath
using namespace ShortestPath;

class Main {
public:
  int sx, sy, gx, gy;
  int n;
  int lx, ly;

  int enc(int x, int y, int t) {
    return t + 6 * ((x + lx) + (2 * lx + 1) * (y + ly));
  }

  void run() {
    cin >> sx >> sy >> gx >> gy;
    cin >> n;
    vector<int> xs(n), ys(n);
    REP(i, n) cin >> xs[i] >> ys[i];

    cin >> lx >> ly;

    vector<vector<Edge>> es(6 * (2 * lx + 1) * (2 * ly + 1));

    vector<vector<bool>> block(2 * ly + 1, vector<bool>(2 * lx + 1));
    REP(i, n) { block[ys[i] + ly][xs[i] + lx] = true; }

    REP(t, 6) {
      for (int y = -ly; y <= ly; y++) {
        for (int x = -lx; x <= lx; x++) {
          int oneesandir = abs(x * y * t) % 6;
          REP(dir, 6) {
            int nx = dir % 3 == 0 ? x : (dir / 3) == 0 ? x + 1 : x - 1;
            int ny = x % 2 == 0 ? (dir == 0                 ? y + 1
                                   : (dir == 1 || dir == 5) ? y
                                                            : y - 1)
                                : (dir == 3                 ? y - 1
                                   : (dir == 2 || dir == 4) ? y
                                                            : y + 1);
            if (!IN(0, nx, 2 * lx + 1) || !IN(0, ny, 2 * ly + 1))
              continue;
            if (block[ny + ly][nx + lx])
              continue;
            es[enc(x, y, t)].push_back(Edge(enc(x, y, t),
                                            enc(nx, ny, (t + 1) % 6),
                                            dir != oneesandir ? 1 : 0));
          }
        }
      }
    }
    vector<int> res = dijkstra(es, enc(sx, sy, 0));

    int mv = INF;
    REP(t, 6) mv = min(mv, res[enc(gx, gy, t)]);

    cout << (mv != INF ? mv : -1) << endl;
  }
};

int main() {
  ios::sync_with_stdio(false);
  Main().run();
  return 0;
}