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

#include <bits/stdc++.h>

using namespace std;

namespace {
template <typename K, typename V>
ostream &operator<<(ostream &os, const pair<K, V> &p) {
  return os << "(" << p.first << "," << p.second << ")";
}
typedef long long ll;
const ll INF = 1LL << 56;
int N, M;

struct Edge {
  int from, to;
  ll cost;
  Edge(int from, int to, ll cost) : from(from), to(to), cost(cost) {}
  bool operator<(const Edge &e) const {
    if (from == e.from) {
      return to == e.to ? cost < e.cost : to < e.to;
    } else {
      return from < e.from;
    }
  }
  bool operator==(const Edge &e) {
    return to == e.to and from == e.from and cost == e.cost;
  }
};
ostream &operator<<(ostream &os, const Edge &e) {
  return os << "Edge(" << e.from << "," << e.to << "," << e.cost << ")";
}
/** output whole vector. ex) vector<int>{1, 2, 3} -> '1 2 3'. */
template <typename T> ostream &operator<<(ostream &os, const vector<T> &xs) {
  if (xs.empty())
    return os;
  os << xs[0];
  for (auto i = 1; i < xs.size(); i++)
    os << ' ' << xs[i];
  return os;
}
vector<vector<Edge>> G, RG;
vector<Edge> es;
map<Edge, int> X;

vector<pair<int, int>> findBridges(const vector<vector<Edge>> &G) {
  int V = N;
  vector<int> dfs_order(V, -1);
  vector<int> lowlink(V, 0);
  int c = 0;
  vector<pair<int, int>> bridges;
  function<void(int, int)> dfs = [&](int v, int prev) {
    dfs_order[v] = c++;
    lowlink[v] = dfs_order[v];
    for (auto &e : G[v]) {
      auto next = e.to;
      if (next == prev)
        continue;
      if (dfs_order[next] >= 0) {
        // already visited. this 'e' is backedge.
        lowlink[v] = min(lowlink[v], dfs_order[next]);
      } else {
        dfs(next, v);
        lowlink[v] = min(lowlink[v], lowlink[next]);
      }
      if (dfs_order[v] < lowlink[next]) {
        auto l = min(v, next);
        auto g = max(v, next);
        bridges.emplace_back(l, g);
      }
    }
  };
  dfs(0, -1);
  return bridges;
}

void input() {
  cin >> N >> M;
  G.resize(N);
  RG.resize(N);
  for (int i = 0; i < M; i++) {
    int a, b;
    ll c;
    cin >> a >> b >> c;
    a--;
    b--;
    Edge e(a, b, c);
    if (X.count(e)) {
      X[e]++;
    } else {
      G[a].emplace_back(a, b, c);
      RG[b].emplace_back(b, a, c);
      X[e] = 1;
    }
    es.emplace_back(a, b, c);
  }
}

struct S {
  int v;
  ll cost;
  S(int v, ll cost) : v(v), cost(cost) {}
  bool operator<(const S &s) const { return cost > s.cost; }
};

void dijkstra(const vector<vector<Edge>> &G, int start, vector<ll> &D,
              vector<vector<Edge>> &prev) {
  priority_queue<S> PQ;
  PQ.emplace(start, 0);
  D[start] = 0;
  while (not PQ.empty()) {
    auto cur = PQ.top();
    PQ.pop();
    for (auto &e : G[cur.v]) {
      auto next = e.to;
      auto ncost = D[cur.v] + e.cost;
      if (D[next] > ncost) {
        prev[next].clear();
        prev[next].push_back(e);
        D[next] = ncost;
        PQ.emplace(next, ncost);
      } else if (D[next] == ncost) {
        prev[next].push_back(e);
      }
    }
  }
}

void solve() {
  vector<ll> D(N, INF);
  vector<ll> RD(N, INF);
  vector<vector<Edge>> prev(N, vector<Edge>());
  vector<vector<Edge>> rprev(N, vector<Edge>());
  dijkstra(G, 0, D, prev);
  dijkstra(RG, 1, RD, rprev);

  vector<vector<Edge>> shortest_paths(N, vector<Edge>());
  vector<bool> used(N, false);
  function<void(int)> dfs = [&](int v) {
    if (prev[v].empty()) {
      // assert(v == 0);
      return;
    }
    if (used[v])
      return;
    used[v] = true;
    for (auto e : prev[v]) {
      shortest_paths[e.from].push_back(e);
      shortest_paths[e.to].emplace_back(e.to, e.from, -1);
      dfs(e.from);
    }
  };
  dfs(1);
  // cout << shortest_paths << endl;

  auto _bridges = findBridges(shortest_paths);
  // cout << _bridges << endl;
  set<pair<int, int>> bridges;
  for (auto b : _bridges) {
    bridges.insert(b);
  }

  for (int i = 0; i < M; i++) {
    auto e = es[i];
    if (D[e.from] + e.cost + RD[e.to] == D[1]) {
      if ((bridges.count(make_pair(e.from, e.to)) or
           bridges.count(make_pair(e.to, e.from))) and
          X[e] <= 1) {
        cout << "SAD" << endl;
      } else {
        cout << "SOSO" << endl;
      }
    } else {
      auto ncost = D[e.to] + e.cost + RD[e.from];
      if (ncost < D[1]) {
        cout << "HAPPY" << endl;
      } else {
        cout << "SOSO" << endl;
      }
    }
  }
}
} // namespace

int main() {
  input();
  solve();
  return 0;
}

Error: 0

Fixed submission:

#include <bits/stdc++.h>

using namespace std;

namespace {
template <typename K, typename V>
ostream &operator<<(ostream &os, const pair<K, V> &p) {
  return os << "(" << p.first << "," << p.second << ")";
}
typedef long long ll;
const ll INF = 1LL << 56;
int N, M;

struct Edge {
  int from, to;
  ll cost;
  Edge(int from, int to, ll cost) : from(from), to(to), cost(cost) {}
  bool operator<(const Edge &e) const {
    if (from == e.from) {
      return to == e.to ? cost < e.cost : to < e.to;
    } else {
      return from < e.from;
    }
  }
  bool operator==(const Edge &e) {
    return to == e.to and from == e.from and cost == e.cost;
  }
};
ostream &operator<<(ostream &os, const Edge &e) {
  return os << "Edge(" << e.from << "," << e.to << "," << e.cost << ")";
}
/** output whole vector. ex) vector<int>{1, 2, 3} -> '1 2 3'. */
template <typename T> ostream &operator<<(ostream &os, const vector<T> &xs) {
  if (xs.empty())
    return os;
  os << xs[0];
  for (auto i = 1; i < xs.size(); i++)
    os << ' ' << xs[i];
  return os;
}
vector<vector<Edge>> G, RG;
vector<Edge> es;
map<Edge, int> X;

vector<pair<int, int>> findBridges(const vector<vector<Edge>> &G) {
  int V = N;
  vector<int> dfs_order(V, -1);
  vector<int> lowlink(V, 0);
  int c = 0;
  vector<pair<int, int>> bridges;
  function<void(int, int)> dfs = [&](int v, int prev) {
    dfs_order[v] = c++;
    lowlink[v] = dfs_order[v];
    for (auto &e : G[v]) {
      auto next = e.to;
      if (next == prev)
        continue;
      if (dfs_order[next] >= 0) {
        // already visited. this 'e' is backedge.
        lowlink[v] = min(lowlink[v], dfs_order[next]);
      } else {
        dfs(next, v);
        lowlink[v] = min(lowlink[v], lowlink[next]);
      }
      if (dfs_order[v] < lowlink[next]) {
        auto l = min(v, next);
        auto g = max(v, next);
        bridges.emplace_back(l, g);
      }
    }
  };
  dfs(0, -1);
  return bridges;
}

void input() {
  cin >> N >> M;
  G.resize(N);
  RG.resize(N);
  for (int i = 0; i < M; i++) {
    int a, b;
    ll c;
    cin >> a >> b >> c;
    a--;
    b--;
    Edge e(a, b, c);
    if (X.count(e)) {
      X[e]++;
    } else {
      G[a].emplace_back(a, b, c);
      RG[b].emplace_back(b, a, c);
      X[e] = 1;
    }
    es.emplace_back(a, b, c);
  }
}

struct S {
  int v;
  ll cost;
  S(int v, ll cost) : v(v), cost(cost) {}
  bool operator<(const S &s) const { return cost > s.cost; }
};

void dijkstra(const vector<vector<Edge>> &G, int start, vector<ll> &D,
              vector<vector<Edge>> &prev) {
  priority_queue<S> PQ;
  PQ.emplace(start, 0);
  D[start] = 0;
  while (not PQ.empty()) {
    auto cur = PQ.top();
    PQ.pop();
    for (auto &e : G[cur.v]) {
      auto next = e.to;
      auto ncost = D[cur.v] + e.cost;
      if (D[next] > ncost) {
        prev[next].clear();
        prev[next].push_back(e);
        D[next] = ncost;
        PQ.emplace(next, ncost);
      } else if (D[next] == ncost) {
        prev[next].push_back(e);
      }
    }
  }
}

void solve() {
  vector<ll> D(N, INF);
  vector<ll> RD(N, INF);
  vector<vector<Edge>> prev(N, vector<Edge>());
  vector<vector<Edge>> rprev(N, vector<Edge>());
  dijkstra(G, 0, D, prev);
  dijkstra(RG, 1, RD, rprev);

  vector<vector<Edge>> shortest_paths(N, vector<Edge>());
  function<void(int)> dfs = [&](int v) {
    if (prev[v].empty()) {
      // assert(v == 0);
      return;
    }
    for (auto e : prev[v]) {
      shortest_paths[e.from].push_back(e);
      shortest_paths[e.to].emplace_back(e.to, e.from, -1);
      dfs(e.from);
    }
  };
  dfs(1);
  // cout << shortest_paths << endl;

  auto _bridges = findBridges(shortest_paths);
  // cout << _bridges << endl;
  set<pair<int, int>> bridges;
  for (auto b : _bridges) {
    bridges.insert(b);
  }

  for (int i = 0; i < M; i++) {
    auto e = es[i];
    if (D[e.from] + e.cost + RD[e.to] == D[1]) {
      if ((bridges.count(make_pair(e.from, e.to)) or
           bridges.count(make_pair(e.to, e.from))) and
          X[e] <= 1) {
        cout << "SAD" << endl;
      } else {
        cout << "SOSO" << endl;
      }
    } else {
      auto ncost = D[e.to] + e.cost + RD[e.from];
      if (ncost < D[1]) {
        cout << "HAPPY" << endl;
      } else {
        cout << "SOSO" << endl;
      }
    }
  }
}
} // namespace

int main() {
  input();
  solve();
  return 0;
}