Problem p02949 (C++)

Buggy submission (status: Runtime Error):
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long int INF = 99999999999999;

// INFを宣言すること。Edgeに辺の情報を入れよう。
class Graph {
  // メンバ変数の説明
  // Edge:一つ目の番号が辺が出る方向
  // MaxV,MaxE:頂点数と辺の数
  // Result系:各メソッドの答え
  // InfinteUpdate:BellmanFordで各番号の頂点までの最短経路が更新されるか
  //
public:
  vector<pair<long long int, long long int>> *Edge;
  long long int MaxV, MaxE;
  long long int *BellmanFordResult, *DijkstraResult, **WarshallFloydResult;
  bool *InfiniteUpdate;
  bool NegativeLoop = false;

  Graph(long long int InputV, long long int InputE) {
    MaxV = InputV;
    MaxE = InputE;
    Edge = new vector<pair<long long int, long long int>>[InputV + 1];
  }

  void BellmanFord(long long int Start) {
    BellmanFordResult = new long long int[MaxV];
    InfiniteUpdate = new bool[MaxV];
    for (int i = 0; i < MaxV; i++) {
      BellmanFordResult[i] = INF;
      InfiniteUpdate[i] = false;
    }
    BellmanFordResult[Start] = 0;
    long long int turn = 0;
    while (true) {
      turn++;
      bool update = false;
      for (int i = 0; i < MaxE; i++) {
        for (int j = 0; j < Edge[i].size(); j++) {
          pair<long long int, long long int> e = Edge[i][j];
          if (turn >= MaxV && InfiniteUpdate[i]) {
            InfiniteUpdate[e.first] = true;
          }
          if (BellmanFordResult[i] != INF &&
              BellmanFordResult[e.first] > BellmanFordResult[i] + e.second) {
            BellmanFordResult[e.first] = BellmanFordResult[i] + e.second;
            update = true;
            if (turn >= MaxV) {
              InfiniteUpdate[e.first] = true;
            }
          }
        }
      }
      if (!update) {
        NegativeLoop = false;
        break;
      }
      if (turn >= 2 * MaxV - 1) {
        NegativeLoop = true;
        break;
      }
    }
  }

  void Dijkstra(long long int Start) {
    DijkstraResult = new long long int[MaxV];
    priority_queue<pair<long long int, long long int>,
                   vector<pair<long long int, long long int>>,
                   greater<pair<long long int, long long int>>>
        que;
    fill(DijkstraResult, DijkstraResult + MaxV, INF);
    DijkstraResult[Start] = 0;
    que.push(pair<long long int, long long int>(0, Start));

    while (!que.empty()) {
      pair<long long int, long long int> p = que.top();
      que.pop();
      long long int v = p.second;
      if (DijkstraResult[v] < p.first)
        continue;
      for (int i = 0; i < Edge[v].size(); i++) {
        pair<long long int, long long int> e = Edge[v][i];
        if (DijkstraResult[e.first] > DijkstraResult[v] + e.second) {
          DijkstraResult[e.first] = DijkstraResult[v] + e.second;
          que.push(pair<long long int, long long int>(DijkstraResult[e.first],
                                                      e.first));
        }
      }
    }
  }

  void WarshallFloyd() {
    WarshallFloydResult = new long long int *[MaxV];
    for (int i = 0; i < MaxV; i++) {
      WarshallFloydResult[i] = new long long int[MaxV];
    }
    for (int i = 0; i < MaxV; i++) {
      for (int j = 0; j < Edge[i].size(); j++) {
        WarshallFloydResult[i][Edge[i][j].first] = Edge[i][j].second;
      }
    }

    for (int k = 0; k < MaxV; k++) {
      for (int i = 0; i < MaxV; i++) {
        for (int j = 0; j < MaxV; j++) {
          WarshallFloydResult[i][j] =
              min(WarshallFloydResult[i][j],
                  WarshallFloydResult[i][k] + WarshallFloydResult[k][j]);
        }
      }
    }
  }
};

int main() {

  long long int N, M, P;
  cin >> N >> M >> P;
  Graph graph(N, M);
  for (int i = 0; i < M; i++) {
    long long int from, to, cost;
    cin >> from >> to >> cost;
    from--;
    to--;
    cost -= P;
    cost = -cost;
    graph.Edge[from].push_back({to, cost});
  }
  graph.BellmanFord(0);
  if (graph.InfiniteUpdate[N - 1]) {
    cout << -1;
  } else {
    cout << max(0LL, -graph.BellmanFordResult[N - 1]);
  }
}

Fixed submission:
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long int INF = 99999999999999;

// INFを宣言すること。Edgeに辺の情報を入れよう。
class Graph {
  // メンバ変数の説明
  // Edge:一つ目の番号が辺が出る方向
  // MaxV,MaxE:頂点数と辺の数
  // Result系:各メソッドの答え
  // InfinteUpdate:BellmanFordで各番号の頂点までの最短経路が更新されるか
  //
public:
  vector<pair<long long int, long long int>> *Edge;
  long long int MaxV, MaxE;
  long long int *BellmanFordResult, *DijkstraResult, **WarshallFloydResult;
  bool *InfiniteUpdate;
  bool NegativeLoop = false;

  Graph(long long int InputV, long long int InputE) {
    MaxV = InputV;
    MaxE = InputE;
    Edge = new vector<pair<long long int, long long int>>[InputV + 1];
  }

  void BellmanFord(long long int Start) {
    BellmanFordResult = new long long int[MaxV];
    InfiniteUpdate = new bool[MaxV];
    for (int i = 0; i < MaxV; i++) {
      BellmanFordResult[i] = INF;
      InfiniteUpdate[i] = false;
    }
    BellmanFordResult[Start] = 0;
    long long int turn = 0;
    while (true) {
      turn++;
      bool update = false;
      for (int i = 0; i < MaxV; i++) {
        for (int j = 0; j < Edge[i].size(); j++) {
          pair<long long int, long long int> e = Edge[i][j];
          if (turn >= MaxV && InfiniteUpdate[i]) {
            InfiniteUpdate[e.first] = true;
          }
          if (BellmanFordResult[i] != INF &&
              BellmanFordResult[e.first] > BellmanFordResult[i] + e.second) {
            BellmanFordResult[e.first] = BellmanFordResult[i] + e.second;
            update = true;
            if (turn >= MaxV) {
              InfiniteUpdate[e.first] = true;
            }
          }
        }
      }
      if (!update) {
        NegativeLoop = false;
        break;
      }
      if (turn >= 2 * MaxV - 1) {
        NegativeLoop = true;
        break;
      }
    }
  }

  void Dijkstra(long long int Start) {
    DijkstraResult = new long long int[MaxV];
    priority_queue<pair<long long int, long long int>,
                   vector<pair<long long int, long long int>>,
                   greater<pair<long long int, long long int>>>
        que;
    fill(DijkstraResult, DijkstraResult + MaxV, INF);
    DijkstraResult[Start] = 0;
    que.push(pair<long long int, long long int>(0, Start));

    while (!que.empty()) {
      pair<long long int, long long int> p = que.top();
      que.pop();
      long long int v = p.second;
      if (DijkstraResult[v] < p.first)
        continue;
      for (int i = 0; i < Edge[v].size(); i++) {
        pair<long long int, long long int> e = Edge[v][i];
        if (DijkstraResult[e.first] > DijkstraResult[v] + e.second) {
          DijkstraResult[e.first] = DijkstraResult[v] + e.second;
          que.push(pair<long long int, long long int>(DijkstraResult[e.first],
                                                      e.first));
        }
      }
    }
  }

  void WarshallFloyd() {
    WarshallFloydResult = new long long int *[MaxV];
    for (int i = 0; i < MaxV; i++) {
      WarshallFloydResult[i] = new long long int[MaxV];
    }
    for (int i = 0; i < MaxV; i++) {
      for (int j = 0; j < Edge[i].size(); j++) {
        WarshallFloydResult[i][Edge[i][j].first] = Edge[i][j].second;
      }
    }

    for (int k = 0; k < MaxV; k++) {
      for (int i = 0; i < MaxV; i++) {
        for (int j = 0; j < MaxV; j++) {
          WarshallFloydResult[i][j] =
              min(WarshallFloydResult[i][j],
                  WarshallFloydResult[i][k] + WarshallFloydResult[k][j]);
        }
      }
    }
  }
};

int main() {

  long long int N, M, P;
  cin >> N >> M >> P;
  Graph graph(N, M);
  for (int i = 0; i < M; i++) {
    long long int from, to, cost;
    cin >> from >> to >> cost;
    from--;
    to--;
    cost -= P;
    cost = -cost;
    graph.Edge[from].push_back({to, cost});
  }
  graph.BellmanFord(0);
  if (graph.InfiniteUpdate[N - 1]) {
    cout << -1;
  } else {
    cout << max(0LL, -graph.BellmanFordResult[N - 1]);
  }
}