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

#include <algorithm>
#include <cmath>
#include <complex>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

typedef complex<double> P;

const double INF = (double)(1 << 29);
const double EPS = 1e-7;

int n, ans;
vector<int> G[20][20];
double r, theta;
bool memo[20][20][10001];
P v[20];

struct state {
  int prev, pos, sum;
  double dis;
  state(int p = 0, int po = 0, int s = 0, double d = 0)
      : prev(p), pos(po), sum(s), dis(d) {}
  bool operator<(const state &s) const { return dis > s.dis; }
};

bool equal(double a, double b) { return fabs(a - b) < EPS; }

double calcTheta(P a, P b, P c) {
  double A = abs(b - a);
  double B = abs(b - c);
  double C = abs(a - c);
  double ans = acos((A * A + B * B - C * C) / (2 * A * B));
  return M_PI - ans;
}

/*
void dfs(int prev, int pos, int sum, double dis){
  //if(memo[prev][pos][sum] <= dis || equal(memo[prev][pos][sum],dis)) return;
  ans = max(ans,sum);
  for(int i=0;i<G[prev][pos].size();i++){
    int next = G[prev][pos][i];
    if(dis + abs(v[pos]-v[next]) > r || memo[pos][next][sum+1] <= dis +
abs(v[pos]-v[next]) || equal(memo[pos][next][sum+1], dis + abs(v[pos]-v[next])))
continue; memo[pos][next][sum+1] = dis + abs(v[pos]-v[next]); dfs(pos, next,
sum+1, dis+abs(v[pos]-v[next]));
  }
}
*/

void bfs() {
  priority_queue<state> Q;
  state u, next;
  for (int i = 1; i < n; i++) {
    if (abs(v[i] - v[0]) > r)
      continue;
    memo[0][i][1] = true;
    Q.push(state(0, i, 1, abs(v[i] - v[0])));
  }

  while (!Q.empty()) {
    u = Q.top();
    Q.pop();
    ans = max(ans, u.sum);
    for (int i = 0; i < G[u.prev][u.pos].size(); i++) {
      next = state(u.pos, G[u.prev][u.pos][i], u.sum + 1, u.dis);
      next.dis += abs(v[u.pos] - v[next.pos]);
      if (next.dis > r || memo[u.pos][next.pos][next.sum])
        continue;
      memo[u.pos][next.pos][next.sum] = true;
      Q.push(next);
    }
  }
}

int main() {
  while (cin >> n) {
    ans = 0;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        G[i][j].clear();
        for (int k = 0; k < 10001; k++)
          memo[i][j][k] = false;
      }
    }

    cin >> r >> theta;
    for (int i = 0; i < n; i++) {
      int x, y;
      cin >> x >> y;
      v[i] = P(x, y);
    }
    theta *= M_PI / 180.0;

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        if (i == j)
          continue;
        for (int k = 0; k < n; k++) {
          if (i == k || j == k)
            continue;
          if (calcTheta(v[i], v[j], v[k]) < theta)
            G[i][j].push_back(k);
        }
      }
    }

    /*
    for(int i=1;i<n;i++){
      if(abs(v[i]-v[0]) > r) continue;
      memo[0][i][1] = abs(v[i]-v[0]);
      dfs(0, i, 1, abs(v[i]-v[0]));
      }
    */
    bfs();

    cout << ans << endl;
  }
}

Error: 0

Fixed submission:

#include <algorithm>
#include <cmath>
#include <complex>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

typedef complex<double> P;

const double INF = (double)(1 << 29);
const double EPS = 1e-7;

int n, ans;
vector<int> G[20][20];
double r, theta;
bool memo[20][20][10001];
P v[20];

struct state {
  int prev, pos, sum;
  double dis;
  state(int p = 0, int po = 0, int s = 0, double d = 0)
      : prev(p), pos(po), sum(s), dis(d) {}
  bool operator<(const state &s) const { return dis > s.dis; }
};

bool equal(double a, double b) { return fabs(a - b) < EPS; }

double calcTheta(P a, P b, P c) {
  double A = abs(b - a);
  double B = abs(b - c);
  double C = abs(a - c);
  double ans = acos((A * A + B * B - C * C) / (2 * A * B));
  return M_PI - ans;
}

/*
void dfs(int prev, int pos, int sum, double dis){
  //if(memo[prev][pos][sum] <= dis || equal(memo[prev][pos][sum],dis)) return;
  ans = max(ans,sum);
  for(int i=0;i<G[prev][pos].size();i++){
    int next = G[prev][pos][i];
    if(dis + abs(v[pos]-v[next]) > r || memo[pos][next][sum+1] <= dis +
abs(v[pos]-v[next]) || equal(memo[pos][next][sum+1], dis + abs(v[pos]-v[next])))
continue; memo[pos][next][sum+1] = dis + abs(v[pos]-v[next]); dfs(pos, next,
sum+1, dis+abs(v[pos]-v[next]));
  }
}
*/

void bfs() {
  priority_queue<state> Q;
  state u, next;
  for (int i = 1; i < n; i++) {
    if (abs(v[i] - v[0]) > r)
      continue;
    memo[0][i][1] = true;
    Q.push(state(0, i, 1, abs(v[i] - v[0])));
  }

  while (!Q.empty()) {
    u = Q.top();
    Q.pop();
    ans = max(ans, u.sum);
    for (int i = 0; i < G[u.prev][u.pos].size(); i++) {
      next = state(u.pos, G[u.prev][u.pos][i], u.sum + 1, u.dis);
      next.dis += abs(v[u.pos] - v[next.pos]);
      if (next.dis > r || next.sum > 10000 || memo[u.pos][next.pos][next.sum])
        continue;
      memo[u.pos][u.pos][next.sum] = true;
      Q.push(next);
    }
  }
}

int main() {
  while (cin >> n) {
    ans = 0;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        G[i][j].clear();
        for (int k = 0; k < 10001; k++)
          memo[i][j][k] = false;
      }
    }

    cin >> r >> theta;
    for (int i = 0; i < n; i++) {
      int x, y;
      cin >> x >> y;
      v[i] = P(x, y);
    }
    theta *= M_PI / 180.0;

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        if (i == j)
          continue;
        for (int k = 0; k < n; k++) {
          if (i == k || j == k)
            continue;
          if (calcTheta(v[i], v[j], v[k]) < theta)
            G[i][j].push_back(k);
        }
      }
    }

    /*
    for(int i=1;i<n;i++){
      if(abs(v[i]-v[0]) > r) continue;
      memo[0][i][1] = abs(v[i]-v[0]);
      dfs(0, i, 1, abs(v[i]-v[0]));
      }
    */
    bfs();

    cout << ans << endl;
  }
}