Problem p02868 (C++)

Buggy submission (status: Runtime Error):
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>

using namespace std;
using pli = pair<int64_t, int>;
using mii = map<int, int>;

struct node {
  mii edge;
  bool done = false;
  int64_t cost = -1;

  bool operator<(const node &rhs) const {
    if (rhs.cost == -1 && this->cost == -1) {
      return false;
    } else if (rhs.cost == -1) {
      return true;
    } else if (this->cost == -1) {
      return false;
    }
    return this->cost < rhs.cost;
  }

  bool operator>(const node &rhs) const { return rhs < *this; }

  void update_cost(int64_t x) noexcept {
    if (x < 0) {
      cerr << "Illegal Argument in node.update_cost: x=" << x << endl;
      exit(1);
    }
    if (this->cost == -1 || this->cost > x) {
      this->cost = x;
    }
  }
};

int main() {
  int N, M;
  cin >> N >> M;

  vector<node> nodes(N);
  mii cover;
  for (auto i = 0; i < M; i++) {
    int L, R, C;
    cin >> L >> R >> C;
    if (cover.count(L - 1) == 0) {
      cover[L - 1] = R - 1;
    } else {
      cover[L - 1] = max(cover[L - 1], R - 1);
    }

    if (nodes.at(L - 1).edge.count(R - 1) == 0) {
      nodes.at(L - 1).edge[R - 1] = C;
    } else {
      nodes.at(L - 1).edge[R - 1] = min(nodes.at(L - 1).edge[R - 1], C);
    }

    if (nodes.at(R - 1).edge.count(L - 1) == 0) {
      nodes.at(R - 1).edge[L - 1] = C;
    } else {
      nodes.at(R - 1).edge[L - 1] = min(nodes.at(R - 1).edge[L - 1], C);
    }
  }

  if (cover.count(0) == 0) {
    cout << -1 << endl;
    return 0;
  }

  auto range = cover.at(0);
  for (auto i = 0; i < cover.size() && i < range; i++) {
    range = max(range, cover.at(i));
    if (range == N - 1) {
      break;
    }
  }

  if (range != N - 1) {
    cout << -1 << endl;
    return 0;
  }

  for (auto i = N - 1; i > 0; i--) {
    nodes.at(i).edge[i - 1] = 0;
  }

  priority_queue<pli, vector<pli>, greater<>> q;

  nodes.at(0).cost = 0;
  q.emplace(0, 0);

  do {
    auto top = q.top();
    q.pop();
    nodes.at(top.second).done = true;
    for (auto e : nodes.at(top.second).edge) {
      nodes.at(e.first).update_cost(top.first + e.second);
      if (!nodes.at(e.first).done) {
        q.emplace(nodes.at(e.first).cost, e.first);
      }
    }
  } while (!q.empty());

  cout << nodes.at(N - 1).cost << endl;
  return 0;
}


Fixed submission:
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>

using namespace std;
using pli = pair<int64_t, int>;
using mii = map<int, int>;

struct node {
  mii edge;
  bool done = false;
  int64_t cost = -1;

  bool operator<(const node &rhs) const {
    if (rhs.cost == -1 && this->cost == -1) {
      return false;
    } else if (rhs.cost == -1) {
      return true;
    } else if (this->cost == -1) {
      return false;
    }
    return this->cost < rhs.cost;
  }

  bool operator>(const node &rhs) const { return rhs < *this; }

  void update_cost(int64_t x) noexcept {
    if (x < 0) {
      cerr << "Illegal Argument in node.update_cost: x=" << x << endl;
      exit(1);
    }
    if (this->cost == -1 || this->cost > x) {
      this->cost = x;
    }
  }
};

int main() {
  int N, M;
  cin >> N >> M;

  vector<node> nodes(N);
  mii cover;
  for (auto i = 0; i < M; i++) {
    int L, R, C;
    cin >> L >> R >> C;
    if (cover.count(L - 1) == 0) {
      cover[L - 1] = R - 1;
    } else {
      cover[L - 1] = max(cover[L - 1], R - 1);
    }

    if (nodes.at(L - 1).edge.count(R - 1) == 0) {
      nodes.at(L - 1).edge[R - 1] = C;
    } else {
      nodes.at(L - 1).edge[R - 1] = min(nodes.at(L - 1).edge[R - 1], C);
    }

    if (nodes.at(R - 1).edge.count(L - 1) == 0) {
      nodes.at(R - 1).edge[L - 1] = C;
    } else {
      nodes.at(R - 1).edge[L - 1] = min(nodes.at(R - 1).edge[L - 1], C);
    }
  }

  if (cover.count(0) == 0) {
    cout << -1 << endl;
    return 0;
  }

  auto range = cover.at(0);
  for (auto i = 1; i < N && i <= range; i++) {
    if (cover.count(i) == 0) {
      continue;
    }
    range = max(range, cover.at(i));
    if (range == N - 1) {
      break;
    }
  }

  if (range != N - 1) {
    cout << -1 << endl;
    return 0;
  }

  for (auto i = N - 1; i > 0; i--) {
    nodes.at(i).edge[i - 1] = 0;
  }

  priority_queue<pli, vector<pli>, greater<>> q;

  nodes.at(0).cost = 0;
  q.emplace(0, 0);

  do {
    auto top = q.top();
    q.pop();
    nodes.at(top.second).done = true;
    for (auto e : nodes.at(top.second).edge) {
      nodes.at(e.first).update_cost(top.first + e.second);
      if (!nodes.at(e.first).done) {
        q.emplace(nodes.at(e.first).cost, e.first);
      }
    }
  } while (!q.empty());

  cout << nodes.at(N - 1).cost << endl;
  return 0;
}