Language: C++

#include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<lint> vlint;
typedef vector<vlint> vvlint;
typedef vector<bool> vbool;
typedef vector<int> vint;


#define inf 1e+9
#define endl "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i < (int)(n); i++)
#define rep_rev(i, n) for (int i = n-1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()

#define pb push_back
#define eb emplace_back
#define Size(c) (int)(c).size()

#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))

template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;

template <class T, class S> inline bool chmax(T &a, S b) {
    if(a < b) {a = b;return 1;} return 0;
}
template <class T, class S> inline bool chmin(T &a, S b) {
    if(a > b) {a = b;return 1;} return 0;
}
template <class T>
void line(vector<T> &x){for (auto&& xi : x) cin >> xi;}

inline void IN(void){ return;}

template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){ cin >> first; IN(rest...); return;}

#define INT(...) int __VA_ARGS__; IN (__VA_ARGS__)
#define LINT(...) lint __VA_ARGS__; IN (__VA_ARGS__)
#define STR(...) string __VA_ARGS__; IN(__VA_ARGS__)

template <class T> void UNIQUE(vector<T> &x) {
    sort(all(x)); x.erase(unique(all(x)), x.end());
}
template <class T> void print_vec(T first, T end){
    for (auto i = first; i < end - 1; i++) cout << *i << " ";
    cout << *(end-1) << endl;
}

template<class... T>
void debug_print(T... args){
    vector<lint> tmp = initializer_list<lint>{args...};
    print_vec(all(tmp));
}
template<class T>
void print(T a){ cout << a << endl;}

vector<string> Yes = {"No", "Yes"};
vector<string> YES = {"NO", "YES"};

int ord(char x){ return (int)(x - 'a');}
char chr(lint x){ return (char)(x + (lint)('a'));}
lint mod = 1e9+7;
// lint mod = 

lint sum(vlint a){lint ret = 0; for(auto&& v:a) ret += v; return ret;}
lint vmini(vlint a, lint &index){
    lint ret = LLONG_MAX;
    rep(i, Size(a)){ if (chmin(ret, a[i])) index = i;}
    return ret;
}
lint vmaxi(vlint a, lint &index){
    lint ret = -LLONG_MAX;
    rep(i, Size(a)){ if (chmax(ret, a[i])) index = i;}
    return ret;
}

lint vmin(vlint a){
    lint ret = LLONG_MAX; for (auto && v : a) chmin(ret, v); return ret;
}
lint vmax(vlint a){
    lint ret = -LLONG_MAX; for (auto && v : a) chmax(ret, v); return ret;
}


vlint base_3(int k){
    vlint ret; while (k > 0){ ret.pb(k % 3); k /= 3;} reverse(all(ret)); return ret;
}
map<lint, lint> trial_division(lint n){
    map<lint, lint> factor;
    lint tmp = (lint)(sqrt(n)) + 1;
    for (lint i = 2; i < tmp; ++i){
        while (n % i == 0){
            n /= i;
            factor[i] ++;
        }
    }
    if(n != 1) factor[n] ++;
    return factor;
}

lint dist(lint x1, lint y1, lint x2, lint y2){
    return (x1-x2) * (x1-x2) + (y1-y2) * (y1 - y2);
}

struct UnionFind{
    vector<int> par;
    int n;
 
    UnionFind(int N) : par(N+1), n(N) { fill(all(par), -1); }
 
    int root(int x) {
        if (par[x] < 0) return x; return par[x] = root(par[x]);
    }
 
    void unite(int x, int y) {
        int rx = root(x); int ry = root(y); if (rx == ry) return;
        if (par[rx] > par[ry]) swap(rx, ry);
        par[rx] += par[ry]; par[ry] = rx;
    }
 
    bool same(int x, int y) {
        int rx = root(x); int ry = root(y); return rx == ry;
    }
 
    int size(int x) { return -par[root(x)];}
};

vbool eratostheness(lint n){

    vbool res(n, true);
    res[0] = res[1] = 0;

    lint i = 2;
    while(i*i <= n){
        for (lint j = 2 * i; j < n+1; j += i){
            if (!(res[j])) continue;

            if (j % i == 0) res[j] = false;
            
        }
        i++;
    }
    return res;
}



int main(){
    INT(r, c, k);
    vvlint value(r+1, vlint(c+1, 0));
    lint a, b, v;
    rep(i, k){
        IN(a, b, v);
        value[a][b] = v;
    }
    vector<vvlint> dp(r+1, vvlint(c+1, vlint(4, 0)));

    rep1(i, r+1){
        rep1(j, c+1){
            dp[i][j][0] = dp[i-1][j][3];
            if (value[i][j] != 0){
                dp[i][j][1] = max(
                    max(
                        dp[i][j][0], dp[i][j-1][0]
                    ) + value[i][j],
                    dp[i][j-1][1]
                );
                rep1(y, 3){
                    dp[i][j][y+1] = max(
                        dp[i][j-1][y] + value[i][j],
                        max(dp[i][j][y], dp[i][j-1][y+1]])
                    );
                }
            }
            else{
                rep(y, 3){
                    dp[i][j][y+1] = max(
                        dp[i][j][y], dp[i][j-1][y+1]]
                    );
                }
            }
        }
    }
    print(dp[r][c][3]);
}


Compiler output:
a.cc: In function 'int main()':
a.cc:175:57: error: expected ')' before ']' token
  175 |                         max(dp[i][j][y], dp[i][j-1][y+1]])
      |                            ~                            ^
      |                                                         )
a.cc:182:53: error: expected ')' before ']' token
  182 |                         dp[i][j][y], dp[i][j-1][y+1]]
      |                                                     ^
      |                                                     )
a.cc:181:40: note: to match this '('
  181 |                     dp[i][j][y+1] = max(
      |                                        ^