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

#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;

const int mod = 1000000007;

struct Mod {
  int num;
  Mod() : num(0) { ; }
  Mod(int n) : num((n % mod + mod) % mod) { ; }
  operator int() { return num; }
};

Mod operator+(Mod a, Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator-(Mod a, Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator*(Mod a, Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod operator^(Mod a, int n) {
  if (n == 0)
    return Mod(1);
  Mod res = (a * a) ^ (n / 2);
  if (n % 2)
    res = res * a;
  return res;
}
Mod inv(Mod a) { return a ^ (mod - 2); }
Mod operator/(Mod a, Mod b) {
  assert(b != 0);
  return a * inv(b);
}

#define MAX_N 1024000

Mod fact[MAX_N], factinv[MAX_N];
void init() {
  fact[0] = Mod(1);
  factinv[0] = 1;
  for (int i = 0; i < MAX_N - 1; ++i) {
    fact[i + 1] = fact[i] * Mod(i + 1);
    factinv[i + 1] = factinv[i] / Mod(i + 1);
  }
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()

int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
struct Node {
  Node(int a, int b, int c) {
    atime = a;
    x = b;
    y = c;
  }
  int atime;
  int x;
  int y;
};
class Compare {
public:
  bool operator()(const Node &l, const Node &r) { return l.atime < r.atime; }
};

int main() {
  while (1) {
    int w, h;
    cin >> w >> h;
    if (!w)
      return 0;
    vector<vector<int>> maze(h + 2, vector<int>(w + 2, 0));

    int xs, ys, xg, yg;
    cin >> xs >> ys >> xg >> yg;
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
      int c, d, x, y;
      cin >> c >> d >> x >> y;
      if (!d) {
        for (int ax = 0; ax < 4; ++ax) {
          for (int ay = 0; ay < 2; ++ay) {
            maze[y + ay][x + ax] = c;
          }
        }
      } else {
        for (int ax = 0; ax < 2; ++ax) {
          for (int ay = 0; ay < 4; ++ay) {
            maze[y + ay][x + ax] = c;
          }
        }
      }
    }
    /*for (int i = 0; i < maze.size(); ++i) {
            for (int j = 0; j < maze[0].size(); ++j) {
                    cout << maze[i][j];
            }
            cout << endl;
    }*/
    int color = maze[ys][xs];
    if (!color || color != maze[yg][xg]) {
      cout << "NG" << endl;
      continue;
    }

    vector<vector<bool>> times(h + 2, vector<bool>(w + 2, false));

    priority_queue<Node, vector<Node>, Compare> qu;
    qu.emplace(0, xs, ys);
    bool flag = false;
    while (!qu.empty()) {
      Node an(qu.top());
      qu.pop();
      if (an.x == xg && an.y == yg) {
        flag = true;
        break;
      } else {
        for (int i = 0; i < 4; ++i) {
          if (maze[an.y + dy[i]][an.x + dx[i]] == color) {
            if (times[an.y + dy[i]][an.x + dx[i]]) {

            } else {
              qu.push(Node{an.atime + 1, an.x + dx[i], an.y + dy[i]});
              times[an.y + dy[i]][an.x + dx[i]] = true;
            }
          }
        }
      }
    }
    if (flag) {
      cout << "OK" << endl;

    } else {
      cout << "NG" << endl;
    }
  }
  return 0;
}

Error: 0

Fixed submission:

#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;

const int mod = 1000000007;

struct Mod {
  int num;
  Mod() : num(0) { ; }
  Mod(int n) : num((n % mod + mod) % mod) { ; }
  operator int() { return num; }
};

Mod operator+(Mod a, Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator-(Mod a, Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator*(Mod a, Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod operator^(Mod a, int n) {
  if (n == 0)
    return Mod(1);
  Mod res = (a * a) ^ (n / 2);
  if (n % 2)
    res = res * a;
  return res;
}
Mod inv(Mod a) { return a ^ (mod - 2); }
Mod operator/(Mod a, Mod b) {
  assert(b != 0);
  return a * inv(b);
}

#define MAX_N 1024000

Mod fact[MAX_N], factinv[MAX_N];
void init() {
  fact[0] = Mod(1);
  factinv[0] = 1;
  for (int i = 0; i < MAX_N - 1; ++i) {
    fact[i + 1] = fact[i] * Mod(i + 1);
    factinv[i + 1] = factinv[i] / Mod(i + 1);
  }
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()

int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
struct Node {
  Node(int a, int b, int c) {
    atime = a;
    x = b;
    y = c;
  }
  int atime;
  int x;
  int y;
};
class Compare {
public:
  bool operator()(const Node &l, const Node &r) { return l.atime < r.atime; }
};

int main() {
  while (1) {
    int w, h;
    cin >> w >> h;
    if (!w)
      return 0;
    vector<vector<int>> maze(w + h + 2, vector<int>(w + h + 2, 0));

    int xs, ys, xg, yg;
    cin >> xs >> ys >> xg >> yg;
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
      int c, d, x, y;
      cin >> c >> d >> x >> y;
      if (!d) {
        for (int ax = 0; ax < 4; ++ax) {
          for (int ay = 0; ay < 2; ++ay) {
            maze[y + ay][x + ax] = c;
          }
        }
      } else {
        for (int ax = 0; ax < 2; ++ax) {
          for (int ay = 0; ay < 4; ++ay) {
            maze[y + ay][x + ax] = c;
          }
        }
      }
    }
    /*for (int i = 0; i < maze.size(); ++i) {
            for (int j = 0; j < maze[0].size(); ++j) {
                    cout << maze[i][j];
            }
            cout << endl;
    }*/
    int color = maze[ys][xs];
    if (!color || color != maze[yg][xg]) {
      cout << "NG" << endl;
      continue;
    }

    vector<vector<bool>> times(h, vector<bool>(w, false));

    priority_queue<Node, vector<Node>, Compare> qu;
    qu.emplace(0, xs, ys);
    bool flag = false;
    while (!qu.empty()) {
      Node an(qu.top());
      qu.pop();
      if (an.x == xg && an.y == yg) {
        flag = true;
        break;
      } else {
        for (int i = 0; i < 4; ++i) {
          if (maze[an.y + dy[i]][an.x + dx[i]] == color) {
            if (times[an.y + dy[i]][an.x + dx[i]]) {

            } else {
              qu.push(Node{an.atime + 1, an.x + dx[i], an.y + dy[i]});
              times[an.y + dy[i]][an.x + dx[i]] = true;
            }
          }
        }
      }
    }
    if (flag) {
      cout << "OK" << endl;

    } else {
      cout << "NG" << endl;
    }
  }
  return 0;
}