Problem p03162 (C++)

Buggy submission (status: Runtime Error):
/**
 *   @author: Kshitiz Srivastava (Pirate_ksh) @ MNNIT Allahabad
 */
#include <bits/stdc++.h>
using namespace std;

// General
#define ll long long
#define io                                                                     \
  ios_base::sync_with_stdio(false);                                            \
  cin.tie(NULL);                                                               \
  cout.tie(NULL);
#define mod 1000000007
#define mod9 998244353
#define endl "\n"
#define debug(x) cout << x << endl
#define REP(i, n) for (i = 0; i < n; ++i)
#define FOR(i, x, n) for (i = x; i < n; ++i)

// Bounds
#define lb(a, x) a.lower_bound(x)
#define ub(a, x) a.upper_bound(x)
#define all(a) a.begin(), a.end()

// Vector
#define vi vector<int>
#define pb(v, x) v.push_back(x)
#define vsi vector<set<int>>

// Map
#define mii map<int, int>

// Set
#define si set<int>

// Pair
#define vpii vector<pair<int, int>>
#define pii pair<int, int>
#define F first
#define S second

ll power_Mod(ll x, ll y) {
  ll res = 1;
  while (y > 0) {
    if (y & 1)
      res = ((res % (ll)mod) * (x % (ll)mod)) % (ll)mod;
    y = y >> 1;
    x = ((x % (ll)mod) * (x % (ll)mod)) % (ll)mod;
  }
  return res;
}

ll power(ll x, ll y) {
  ll res = 1;
  while (y > 0) {
    if (y & 1)
      res = res * x;
    y = y >> 1;
    x = x * x;
  }
  return res;
}

int is_palin(string s) {
  int i, len = s.length();
  for (i = 0; i < len / 2; i++)
    if (s[i] != s[len - i - 1])
      break;
  if (i == len / 2)
    return 1;
  else
    return 0;
}

ll ceiling(double d) {
  ll d_ = (ll)d;
  if (d == d_)
    return d_;
  else
    return d_ + 1;
}

ll flooring(double d) {
  ll d_ = (ll)d;
  return d_;
}

void showSet(set<int> s) {
  si::iterator it;
  it = s.begin();
  while (it != s.end()) {
    cout << (*it) << " ";
    it++;
  }
  cout << endl;
}

bool cmp(string a, string b) {
  ll x = a.length();
  ll y = b.length();
  // if(x != y) return x < y;
  return x < y;
}

/*******************
    NUMBER THEORY
********************/

void prime_factors(int n) {
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      cout << i << " ";
      while (n % i == 0)
        n /= i;
    }
  }
  if (n > 1)
    cout << n << " ";
}

bool is_prime(int n) {
  int i, flag = 0;
  for (i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      flag = 1;
      break;
    }
  }
  if (flag == 1)
    return false;
  return true;
}

// bool prime[1000000+1];
// void SieveOfEratosthenes()
// {
//     memset(prime, true, sizeof(prime));
//     for (int p=2; p*p<=1000000+1; p++)
//     {
//         if (prime[p] == true)
//         {
//             for (int i=p*p; i<=1000000+1; i += p)
//                 prime[i] = false;
//         }
//     }
// }

/**********************
    NUMBER THEORY ENDS
***********************/

/*****************************
    FOR C(n, r) and P(n, r)
*****************************/
/*
ll fact[1000000 + 1];
ll invfact[1000000 + 1];
void calcFact() {
    fact[0] = 1;
    for(ll i = 1; i <= 1000000; i++)
        fact[i] = ((fact[i - 1] % mod) * (i % mod) ) % mod;
}

void calcInvFact() {
    invfact[0] = 1;
    for(ll i = 1; i <= 1000000; i++)
        invfact[i] = (power_moD(fact[i], mod - 2) % mod);
}

ll nCr(ll n, ll r) {
    return ((((fact[n] % mod) * (invfact[r] % mod)) % mod) * (invfact[n-r] %
mod) ) % mod;
}
*/
/*****************************
    C(n, r) and P(n, r) ENDS
*****************************/

/*************************
     GRAPH ALGORITHMS
**************************/
// bool visited[100000+1] = {false};
/* Depth First Search */
// void dfs(vi graph[], int n) {
//     visited[n] = true;
//     ll size = graph[n].size();
//     for(int i: graph[n]) {
//         if(!visited[i]) {
//             dfs(graph, i);
//         }
//     }
// }
/* Breadth First Search */
// queue<int> Q;
// void bfs(vi graph[], int n) {
//     int v;
//     Q.push(n);
//     visited[n] = true;
//     while(!Q.empty()) {
//         v = Q.front();
//         Q.pop();
//         for(int i: graph[v]) {
//             if(!visited[i]){
//                 visited[i] = true;
//                 Q.push(i);
//             }
//         }
//     }
//  }

// void add_edge(vi graph[], int a, int b) {
//     pb(graph[a], b);
//     pb(graph[b], a);
// }

/* Disjoint Set Union (DSU) */
// vi size(100000+1, 1);
// vi graph(100000+1);
// int root(int i) {
//     // Finding root of any element
//     while(graph[i] != i) {
//         graph[i] = graph[graph[i]]; // Path compression
//         i = graph[i];
//     }
//     return i;
// }

// bool find_(int p, int q) {
//     // Check whether two elements are in same subset
//     int root_p = root(p);
//     int root_q = root(q);
//     if(root_p == root_q) return true;
//     return false;
// }

// void dsu(int p, int q) {
//     // Union of two elements
//     int root_p = root(p);
//     int root_q = root(q);
//     if(!find_(p, q)) {
//         if(size[root_p] > size[root_q]) {
//             // root of p will be ultimate root
//             graph[root_q] = root_p;
//             size[root_p] += size[root_q];
//         }
//         else {
//             // root of q will be ultimate root
//             graph[root_p] = root_q;
//             size[root_q] += size[root_p];
//         }
//     }
// }

/*******************
   GRAPH ALGO ENDS
*******************/
// int bits[32] = {0};
// mii chk;
// void countSetBits(int n) {
//     int  i = 0;
//     int temp = n;
//     while(temp) {
//         if(temp&1){
//             bits[i]++;
//             chk[i] = n;
//         }
//         temp>>=1;
//         ++i;
//     }
// }

int main() {
#ifndef ONLINE_JUDGE
  FILE *input, *output;
  // for getting input from input.txt
  input = freopen("input.txt", "r", stdin);
  // for writing output to output.txt
  // output = freopen("output.txt", "w", stdout);
#endif
  io;
  ll t, n, i, j;
  t = 1;
  // cin >> t;
  while (t--) {
    cin >> n;
    vi a(n), b(n), c(n);
    REP(i, n) cin >> a[i] >> b[i] >> c[i];
    int dp[n][3];
    dp[0][0] = a[0];
    dp[0][1] = b[0];
    dp[0][2] = c[0];
    FOR(i, 1, n) {
      dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
      dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
      dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
    }

    cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
  }
  return 0;
}

Fixed submission:
/**
 *   @author: Kshitiz Srivastava (Pirate_ksh) @ MNNIT Allahabad
 */
#include <bits/stdc++.h>
using namespace std;

// General
#define ll long long
#define io                                                                     \
  ios_base::sync_with_stdio(false);                                            \
  cin.tie(NULL);                                                               \
  cout.tie(NULL);
#define mod 1000000007
#define mod9 998244353
#define endl "\n"
#define debug(x) cout << x << endl
#define REP(i, n) for (i = 0; i < n; ++i)
#define FOR(i, x, n) for (i = x; i < n; ++i)

// Bounds
#define lb(a, x) a.lower_bound(x)
#define ub(a, x) a.upper_bound(x)
#define all(a) a.begin(), a.end()

// Vector
#define vi vector<int>
#define pb(v, x) v.push_back(x)
#define vsi vector<set<int>>

// Map
#define mii map<int, int>

// Set
#define si set<int>

// Pair
#define vpii vector<pair<int, int>>
#define pii pair<int, int>
#define F first
#define S second

ll power_Mod(ll x, ll y) {
  ll res = 1;
  while (y > 0) {
    if (y & 1)
      res = ((res % (ll)mod) * (x % (ll)mod)) % (ll)mod;
    y = y >> 1;
    x = ((x % (ll)mod) * (x % (ll)mod)) % (ll)mod;
  }
  return res;
}

ll power(ll x, ll y) {
  ll res = 1;
  while (y > 0) {
    if (y & 1)
      res = res * x;
    y = y >> 1;
    x = x * x;
  }
  return res;
}

int is_palin(string s) {
  int i, len = s.length();
  for (i = 0; i < len / 2; i++)
    if (s[i] != s[len - i - 1])
      break;
  if (i == len / 2)
    return 1;
  else
    return 0;
}

ll ceiling(double d) {
  ll d_ = (ll)d;
  if (d == d_)
    return d_;
  else
    return d_ + 1;
}

ll flooring(double d) {
  ll d_ = (ll)d;
  return d_;
}

void showSet(set<int> s) {
  si::iterator it;
  it = s.begin();
  while (it != s.end()) {
    cout << (*it) << " ";
    it++;
  }
  cout << endl;
}

bool cmp(string a, string b) {
  ll x = a.length();
  ll y = b.length();
  // if(x != y) return x < y;
  return x < y;
}

/*******************
    NUMBER THEORY
********************/

void prime_factors(int n) {
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      cout << i << " ";
      while (n % i == 0)
        n /= i;
    }
  }
  if (n > 1)
    cout << n << " ";
}

bool is_prime(int n) {
  int i, flag = 0;
  for (i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      flag = 1;
      break;
    }
  }
  if (flag == 1)
    return false;
  return true;
}

// bool prime[1000000+1];
// void SieveOfEratosthenes()
// {
//     memset(prime, true, sizeof(prime));
//     for (int p=2; p*p<=1000000+1; p++)
//     {
//         if (prime[p] == true)
//         {
//             for (int i=p*p; i<=1000000+1; i += p)
//                 prime[i] = false;
//         }
//     }
// }

/**********************
    NUMBER THEORY ENDS
***********************/

/*****************************
    FOR C(n, r) and P(n, r)
*****************************/
/*
ll fact[1000000 + 1];
ll invfact[1000000 + 1];
void calcFact() {
    fact[0] = 1;
    for(ll i = 1; i <= 1000000; i++)
        fact[i] = ((fact[i - 1] % mod) * (i % mod) ) % mod;
}

void calcInvFact() {
    invfact[0] = 1;
    for(ll i = 1; i <= 1000000; i++)
        invfact[i] = (power_moD(fact[i], mod - 2) % mod);
}

ll nCr(ll n, ll r) {
    return ((((fact[n] % mod) * (invfact[r] % mod)) % mod) * (invfact[n-r] %
mod) ) % mod;
}
*/
/*****************************
    C(n, r) and P(n, r) ENDS
*****************************/

/*************************
     GRAPH ALGORITHMS
**************************/
// bool visited[100000+1] = {false};
/* Depth First Search */
// void dfs(vi graph[], int n) {
//     visited[n] = true;
//     ll size = graph[n].size();
//     for(int i: graph[n]) {
//         if(!visited[i]) {
//             dfs(graph, i);
//         }
//     }
// }
/* Breadth First Search */
// queue<int> Q;
// void bfs(vi graph[], int n) {
//     int v;
//     Q.push(n);
//     visited[n] = true;
//     while(!Q.empty()) {
//         v = Q.front();
//         Q.pop();
//         for(int i: graph[v]) {
//             if(!visited[i]){
//                 visited[i] = true;
//                 Q.push(i);
//             }
//         }
//     }
//  }

// void add_edge(vi graph[], int a, int b) {
//     pb(graph[a], b);
//     pb(graph[b], a);
// }

/* Disjoint Set Union (DSU) */
// vi size(100000+1, 1);
// vi graph(100000+1);
// int root(int i) {
//     // Finding root of any element
//     while(graph[i] != i) {
//         graph[i] = graph[graph[i]]; // Path compression
//         i = graph[i];
//     }
//     return i;
// }

// bool find_(int p, int q) {
//     // Check whether two elements are in same subset
//     int root_p = root(p);
//     int root_q = root(q);
//     if(root_p == root_q) return true;
//     return false;
// }

// void dsu(int p, int q) {
//     // Union of two elements
//     int root_p = root(p);
//     int root_q = root(q);
//     if(!find_(p, q)) {
//         if(size[root_p] > size[root_q]) {
//             // root of p will be ultimate root
//             graph[root_q] = root_p;
//             size[root_p] += size[root_q];
//         }
//         else {
//             // root of q will be ultimate root
//             graph[root_p] = root_q;
//             size[root_q] += size[root_p];
//         }
//     }
// }

/*******************
   GRAPH ALGO ENDS
*******************/
// int bits[32] = {0};
// mii chk;
// void countSetBits(int n) {
//     int  i = 0;
//     int temp = n;
//     while(temp) {
//         if(temp&1){
//             bits[i]++;
//             chk[i] = n;
//         }
//         temp>>=1;
//         ++i;
//     }
// }

int main() {
  io;
  ll t, n, i, j;
  t = 1;
  // cin >> t;
  while (t--) {
    cin >> n;
    vi a(n), b(n), c(n);
    REP(i, n) cin >> a[i] >> b[i] >> c[i];
    int dp[n][3];
    dp[0][0] = a[0];
    dp[0][1] = b[0];
    dp[0][2] = c[0];
    FOR(i, 1, n) {
      dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
      dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
      dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
    }

    cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
  }
  return 0;
}