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

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <complex>

#include <cassert>
#include <functional>

typedef long long ll;
using namespace std;

#define debug(x) cerr << #x << " = " << (x) << endl;

#define mod 1000000007              // 1e9+7(prime number)
#define INF 1000000000              // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 100010

/* Bridges */

int bridges_dfs(int now, int backID, vector<vector<pair<int, int>>> &way,
                vector<int> &visited, vector<int> &sum,
                vector<bool> &bridges_flag) {
  int res_sum = 0;

  visited[now] = 1;

  for (int i = 0; i < way[now].size(); i++) {
    pair<int, int> p = way[now][i];
    if (p.second == backID)
      continue;

    if (visited[p.first] == 1) {
      sum[p.first]--;
      sum[now]++;
      bridges_flag[p.second] = false;
    } else if (visited[p.first] == 0) {
      int res = bridges_dfs(p.first, p.second, way, visited, sum, bridges_flag);
      res_sum += res;
      if (res > 0) {
        bridges_flag[p.second] = false;
      }
    }
  }

  visited[now] = 2;
  return res_sum + sum[now];
}

vector<bool>
bridges(int n, const vector<pair<int, int>> &path) { // 無向辺 & 多重辺考慮
  vector<vector<pair<int, int>>> way(n);
  vector<int> visited(n, 0), sum(n, 0);
  vector<bool> bridges_flag(path.size(), true);

  for (int i = 0; i < path.size(); i++) {
    way[path[i].first].push_back({path[i].second, i});
    way[path[i].second].push_back({path[i].first, i});
  }

  bridges_dfs(0, -1, way, visited, sum, bridges_flag);

  return bridges_flag;
}

int main() {
  int n, m;
  int a[SIZE], b[SIZE], c[SIZE];
  vector<int> way[SIZE], rway[SIZE];

  scanf("%d%d", &n, &m);

  for (int i = 0; i < m; i++) {
    scanf("%d%d%d", a + i, b + i, c + i);
    a[i]--;
    b[i]--;

    way[a[i]].push_back(i);
    rway[b[i]].push_back(i);
  }

  // Dijkstra
  priority_queue<pair<ll, int>> pq;
  bool visited[SIZE] = {}, rvisited[SIZE];
  ll cost[SIZE], rcost[SIZE];

  pq.push({0, 0});

  while (pq.size()) {
    auto p = pq.top();
    pq.pop();

    int now = p.second;
    ll cur_cost = p.first;

    if (visited[now])
      continue;
    visited[now] = true;
    cost[now] = -cur_cost;

    for (int i = 0; i < way[now].size(); i++) {
      int id = way[now][i];
      pq.push({cur_cost - c[id], b[id]});
    }
  }

  pq.push({0, 1});

  while (pq.size()) {
    auto p = pq.top();
    pq.pop();

    int now = p.second;
    ll cur_cost = p.first;

    if (rvisited[now])
      continue;
    rvisited[now] = true;
    rcost[now] = -cur_cost;

    for (int i = 0; i < rway[now].size(); i++) {
      int id = rway[now][i];
      pq.push({cur_cost - c[id], a[id]});
    }
  }

  vector<pair<int, int>> Graph;
  vector<int> pathID;
  bool visited2[SIZE] = {};

  pq.push({cost[1], 1});

  while (pq.size()) {
    auto p = pq.top();
    pq.pop();

    int now = p.second;
    ll cur_cost = p.first;

    if (visited2[now])
      continue;
    visited2[now] = true;

    for (int i = 0; i < rway[now].size(); i++) {
      int id = rway[now][i];
      if (cur_cost - c[id] == cost[a[id]]) {
        pq.push({cost[a[id]], a[id]});
        Graph.push_back({a[id], b[id]});
        pathID.push_back(id);
      }
    }
  }

  auto res = bridges(n, Graph);
  bool isBridge[SIZE] = {};

  for (int i = 0; i < res.size(); i++) {
    int id = pathID[i];
    isBridge[id] = res[i];
  }

  for (int i = 0; i < m; i++) {
    if (isBridge[i]) {
      puts("SAD");
    } else if (visited[b[i]] && rvisited[a[i]] &&
               cost[b[i]] + rcost[a[i]] + c[i] < cost[1]) {
      puts("HAPPY");
    } else {
      puts("SOSO");
    }
  }

  return 0;
}


Error: 0
"False" = False


Fixed submission:

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <complex>

#include <cassert>
#include <functional>

typedef long long ll;
using namespace std;

#define debug(x) cerr << #x << " = " << (x) << endl;

#define mod 1000000007              // 1e9+7(prime number)
#define INF 1000000000              // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 100010

/* Bridges */

int bridges_dfs(int now, int backID, vector<vector<pair<int, int>>> &way,
                vector<int> &visited, vector<int> &sum,
                vector<bool> &bridges_flag) {
  int res_sum = 0;

  visited[now] = 1;

  for (int i = 0; i < way[now].size(); i++) {
    pair<int, int> p = way[now][i];
    if (p.second == backID)
      continue;

    if (visited[p.first] == 1) {
      sum[p.first]--;
      sum[now]++;
      bridges_flag[p.second] = false;
    } else if (visited[p.first] == 0) {
      int res = bridges_dfs(p.first, p.second, way, visited, sum, bridges_flag);
      res_sum += res;
      if (res > 0) {
        bridges_flag[p.second] = false;
      }
    }
  }

  visited[now] = 2;
  return res_sum + sum[now];
}

vector<bool>
bridges(int n, const vector<pair<int, int>> &path) { // 無向辺 & 多重辺考慮
  vector<vector<pair<int, int>>> way(n, vector<pair<int, int>>());
  vector<int> visited(n, 0), sum(n, 0);
  vector<bool> bridges_flag(path.size(), true);

  for (int i = 0; i < path.size(); i++) {
    way[path[i].first].push_back({path[i].second, i});
    way[path[i].second].push_back({path[i].first, i});
  }

  bridges_dfs(0, -1, way, visited, sum, bridges_flag);

  return bridges_flag;
}

int n, m;
int a[SIZE], b[SIZE], c[SIZE];
vector<int> way[SIZE], rway[SIZE];

priority_queue<pair<ll, int>> pq;
bool visited[SIZE] = {}, rvisited[SIZE] = {};
ll cost[SIZE], rcost[SIZE];

vector<pair<int, int>> Graph;
vector<int> pathID;
bool visited2[SIZE] = {};

bool isBridge[SIZE] = {};

int main() {

  scanf("%d%d", &n, &m);

  for (int i = 0; i < m; i++) {
    scanf("%d%d%d", a + i, b + i, c + i);
    a[i]--;
    b[i]--;

    way[a[i]].push_back(i);
    rway[b[i]].push_back(i);
  }

  // Dijkstra

  pq.push({0, 0});

  while (pq.size()) {
    auto p = pq.top();
    pq.pop();

    int now = p.second;
    ll cur_cost = p.first;

    if (visited[now])
      continue;
    visited[now] = true;
    cost[now] = -cur_cost;

    for (int i = 0; i < way[now].size(); i++) {
      int id = way[now][i];
      pq.push({cur_cost - c[id], b[id]});
    }
  }

  pq.push({0, 1});

  while (pq.size()) {
    auto p = pq.top();
    pq.pop();

    int now = p.second;
    ll cur_cost = p.first;

    if (rvisited[now])
      continue;
    rvisited[now] = true;
    rcost[now] = -cur_cost;

    for (int i = 0; i < rway[now].size(); i++) {
      int id = rway[now][i];
      pq.push({cur_cost - c[id], a[id]});
    }
  }

  pq.push({cost[1], 1});

  while (pq.size()) {
    auto p = pq.top();
    pq.pop();

    int now = p.second;
    int cur_cost = p.first;

    if (visited2[now])
      continue;
    visited2[now] = true;

    for (int i = 0; i < rway[now].size(); i++) {
      int id = rway[now][i];
      if (cur_cost - c[id] == cost[a[id]]) {
        pq.push({cost[a[id]], a[id]});
        Graph.push_back({a[id], b[id]});
        pathID.push_back(id);
      }
    }
  }

  auto res = bridges(n, Graph);

  for (int i = 0; i < res.size(); i++) {
    int id = pathID[i];
    isBridge[id] = res[i];
  }

  for (int i = 0; i < m; i++) {
    if (isBridge[i]) {
      puts("SAD");
    } else if (visited[b[i]] && rvisited[a[i]] &&
               cost[b[i]] + rcost[a[i]] + c[i] < cost[1]) {
      puts("HAPPY");
    } else {
      puts("SOSO");
    }
  }

  debug("False");

  return 0;
}