Problem p02586 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <bits/stdc++.h>
using namespace std;
/*
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
        #include <boost/multiprecision/cpp_int.hpp>
        #include <boost/multiprecision/cpp_dec_float.hpp>
        using bll = boost::multiprecision::cpp_int;
        using bdouble =
boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>>; using
namespace boost::multiprecision; #endif
*/
#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \\
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
#ifdef LOCAL_DEV
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\\n";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\\t" << (*itr).first << " : " << (*itr).second << "\\n";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
void debug_impl() { std::cerr << '\\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \\
  do {                                                                         \\
    std::cerr << "(" << #__VA_ARGS__ << ") =";                                 \\
    debug_impl(__VA_ARGS__);                                                   \\
  } while (false)
#else
#define debug(...)                                                             \\
  do {                                                                         \\
  } while (false)
#endif
// #define int long long
using ll = long long;
// constexpr int INF = (ll)1e9 + 7;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18; //(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
#define rep(i, n) for (ll i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (ll i = 1, i##_length = (n); i <= i##_length; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrepeq(i, n) for (ll i = (n); i >= 1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\\n'; }
template <typename Head, typename... Tail> void p(Head head, Tail... tail) {
  std::cout << head << (sizeof...(tail) ? " " : "");
  p(tail...);
}
template <typename T> inline void pv(std::vector<T> &v) {
  for (ll i = 0, N = v.size(); i < N; i++)
    std::cout << v[i] << " \\n"[i == N - 1];
}
template <typename T> inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <typename T> inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
template <typename T> inline void uniq(std::vector<T> &v) {
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

/*-----8<-----template-----8<-----*/
#define LOCAL_DEBUGDP
namespace debugdpdetail {
template <typename Tp, size_t N>
std::vector<Tp>
debugdp_impl(ll index, std::vector<Tp> &dp, std::vector<ll> &dpitemsize,
             typename std::enable_if<(N == 1), Tp const &>::type x) {
  std::vector<Tp> ans(dpitemsize[1], x);
  for (ll i = 0; i < dpitemsize[1]; i++)
    ans[i] = dp[i + index];
  return ans;
}
template <typename Tp, size_t N>
auto debugdp_impl(ll index, std::vector<Tp> &dp, std::vector<ll> &dpitemsize,
                  typename std::enable_if<(N > 1), Tp const &>::type x) {
  std::vector<decltype(debugdp_impl<Tp, N - 1>(index, dp, dpitemsize, x))> ans;
  for (ll i = 0, size = dpitemsize[N] / dpitemsize[N - 1]; i < size; i++) {
    ans.push_back(debugdp_impl<Tp, N - 1>(index + dpitemsize[N - 1] * i, dp,
                                          dpitemsize, x));
  }
  return ans;
}
} // namespace debugdpdetail

namespace makevectordetail {
template <typename Tp, size_t N>
std::vector<Tp>
make_vector(std::vector<size_t> &sizes,
            typename std::enable_if<(N == 1), Tp const &>::type x) {
  return std::vector<Tp>(sizes[0], x);
}
template <typename Tp, size_t N>
auto make_vector(std::vector<size_t> &sizes,
                 typename std::enable_if<(N > 1), Tp const &>::type x) {
  size_t size = sizes[N - 1];
  sizes.pop_back();
  return std::vector<decltype(make_vector<Tp, N - 1>(sizes, x))>(
      size, make_vector<Tp, N - 1>(sizes, x));
}
} // namespace makevectordetail
template <typename Tp, typename sizetype, size_t N>
auto make_vector(sizetype const (&sizes)[N], Tp const &x = Tp()) {
  std::vector<size_t> s(N);
  for (size_t i = 0; i < N; ++i)
    s[i] = sizes[N - i - 1];
  return makevectordetail::make_vector<Tp, N>(s, x);
}
// vector<vector<vector<ll>>> dp = make_vector<ll>({1, 2, 3}, 0LL);
/*-----8<-----library-----8<-----*/

constexpr ll R_MAX = 3000;
constexpr ll C_MAX = 3000;
constexpr ll V_I_MAX = 1e9;

ll R, C, K;
vector<ll> r;
vector<ll> c;
vector<ll> v;

void solve() {
  cin >> R >> C >> K;
  r = vector<ll>(K);
  c = vector<ll>(K);
  v = vector<ll>(K);
  rep(i, K) {
    cin >> r[i] >> c[i] >> v[i];
    r[i]--, c[i]--;
  }

  vector<vector<pair<ll, ll>>> item(R);
  rep(i, K) { item[r[i]].push_back({c[i], v[i]}); }
  rep(i, R) sort(all(item[i]));
  // debug(item);

  using dptype = ll;
  ll dpeachsize[] = {R + 1, C + 1, 4};
  constexpr ll dpeacharrsize = extent<decltype(dpeachsize), 0>::value;
  vector<ll> dpitemsize(dpeacharrsize + 1, 1);
  for (ll i = 0; i < dpeacharrsize; ++i)
    dpitemsize[i + 1] = dpitemsize[i] * dpeachsize[dpeacharrsize - 1 - i];
  // vector<dptype> dp(dpitemsize.back(), 0);
  vector<vector<vector<ll>>> dp = make_vector<ll>({R + 1, C + 1, 4LL}, 0LL);
/*
vector<bool> checked(dpitemsize.back(), false);
auto getindex = [&](auto&&... args) {
        assert(sizeof...(args) == dpeacharrsize);
        ll ans=0, i=dpeacharrsize-1; for(auto&& n : {args...}) ans +=
dpitemsize[i] * n, --i; return ans;
};
*/
#if defined(LOCAL_DEV) && defined(LOCAL_DEBUGDP)
  [[maybe_unused]] auto debugdp_lambda = [&](vector<dptype> &v) {
    auto dp = debugdpdetail::debugdp_impl<dptype, dpeacharrsize>(
        0, v, dpitemsize, dptype(0));
    debug(dp);
  };
#define debugdp(v)                                                             \\
  do {                                                                         \\
    debugdp_lambda(v);                                                         \\
  } while (false)
#else
#define debugdp(...)                                                           \\
  do {                                                                         \\
  } while (false)
#endif
  // auto f = [&](auto&& f, ll x, ll y, ll nokori) -> dptype {
  rrep(x, R) rrep(y, C) rep(nokori, 4) {
    if (x >= R) {
      dp[x][y][nokori] = 0;
      continue;
    }
    // ll dparrindex = getindex(x,y,nokori);
    // debug(x,y);
    // if(checked[dparrindex]) return dp[dparrindex];

    dptype ans = 0;

    if (nokori) {
      auto it = lower_bound(all(item[x]), pair<ll, ll>(y, 0),
                            [](const pair<ll, ll> &x, const pair<ll, ll> &y) {
                              return x.first < y.first;
                            });
      for (; it != item[x].end(); it++) {
        // ll t=f(f, x, it->first+1, nokori-1) + it->second;
        ll t = dp[x][it->first + 1][nokori - 1] + it->second;
        ll s = dp[x + 1][it->first][3] + it->second;
        chmax(ans, t);
        chmax(ans, s);
      }
    }

    ll s = dp[x + 1][y][3];
    chmax(ans, s);

    // checked[dparrindex] = true;
    // return dp[dparrindex] = ans;
    dp[x][y][nokori] = ans;
  }
  // dptype ans = f(f, 0, 0, 3);
  // debugdp(dp);
  ll ans = dp[0][0][3];

  // debug(f(f,1,2,2));

  cout << ans << '\\n';
}

// https://atcoder.jp/contests/abc175/tasks/abc175_e
signed main() {
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  // ll Q; cin >> Q; while(Q--)solve();
  solve();
  return 0;
}


Error: TLE

Fixed submission:

#include <bits/stdc++.h>
using namespace std;
/*
#if __has_include(<boost/multiprecision/cpp_int.hpp>)
        #include <boost/multiprecision/cpp_int.hpp>
        #include <boost/multiprecision/cpp_dec_float.hpp>
        using bll = boost::multiprecision::cpp_int;
        using bdouble =
boost::multiprecision::number<boost::multiprecision::cpp_dec_float<100>>; using
namespace boost::multiprecision; #endif
*/
#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \\
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
namespace std {
template <typename T> class dvector : public std::vector<T> {
public:
  dvector() : std::vector<T>() {}
  explicit dvector(size_t n, const T &value = T()) : std::vector<T>(n, value) {}
  dvector(const std::vector<T> &v) : std::vector<T>(v) {}
  dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
  dvector(const std::string::iterator first, const std::string::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::iterator first,
          const typename std::vector<T>::iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::reverse_iterator first,
          const typename std::vector<T>::reverse_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_iterator first,
          const typename std::vector<T>::const_iterator last)
      : std::vector<T>(first, last) {}
  dvector(const typename std::vector<T>::const_reverse_iterator first,
          const typename std::vector<T>::const_reverse_iterator last)
      : std::vector<T>(first, last) {}
  T &operator[](size_t n) {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
  const T &operator[](size_t n) const {
    try {
      return this->at(n);
    } catch (const std::exception &e) {
      std::cerr << boost::stacktrace::stacktrace() << '\\n';
      return this->at(n);
    }
  }
};
} // namespace std
class dbool {
private:
  bool boolvalue;

public:
  dbool() : boolvalue(false) {}
  dbool(bool b) : boolvalue(b) {}
  operator bool &() { return boolvalue; }
  operator const bool &() const { return boolvalue; }
};
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGFPE_exception();
}
void catch_SIGSEGV([[maybe_unused]] int e) {
  std::cerr << boost::stacktrace::stacktrace() << '\\n';
  throw SIGSEGV_exception();
}
signed convertedmain();
signed main() {
  signal(SIGFPE, catch_SIGFPE);
  signal(SIGSEGV, catch_SIGSEGV);
  return convertedmain();
}
#define main() convertedmain()
#endif
#ifdef LOCAL_DEV
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
                         const std::vector<std::vector<T>> &vv) {
  s << "\\\\\\n";
  for (size_t i = 0; i < vv.size(); ++i) {
    s << vv[i] << "\\n";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
  for (size_t i = 0; i < v.size(); ++i) {
    s << v[i];
    if (i < v.size() - 1)
      s << "\\t";
  }
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::multiset<T> &se) {
  s << "{ ";
  for (auto itr = se.begin(); itr != se.end(); ++itr) {
    s << (*itr) << "\\t";
  }
  s << "}";
  return s;
}
template <typename T, size_t N>
std::ostream &operator<<(std::ostream &s, const std::array<T, N> &a) {
  s << "{ ";
  for (size_t i = 0; i < N; ++i) {
    s << a[i] << "\\t";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::map<T1, T2> &m) {
  s << "{\\n";
  for (auto itr = m.begin(); itr != m.end(); ++itr) {
    s << "\\t" << (*itr).first << " : " << (*itr).second << "\\n";
  }
  s << "}";
  return s;
}
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &s, const std::pair<T1, T2> &p) {
  return s << "(" << p.first << ", " << p.second << ")";
}
void debug_impl() { std::cerr << '\\n'; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head << (sizeof...(tail) ? "," : "");
  debug_impl(tail...);
}
#define debug(...)                                                             \\
  do {                                                                         \\
    std::cerr << "(" << #__VA_ARGS__ << ") =";                                 \\
    debug_impl(__VA_ARGS__);                                                   \\
  } while (false)
#else
#define debug(...)                                                             \\
  do {                                                                         \\
  } while (false)
#endif
// #define int long long
using ll = long long;
// constexpr int INF = (ll)1e9 + 7;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18; //(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
#define rep(i, n) for (ll i = 0, i##_length = (n); i < i##_length; ++i)
#define repeq(i, n) for (ll i = 1, i##_length = (n); i <= i##_length; ++i)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define rrepeq(i, n) for (ll i = (n); i >= 1; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
void p() { std::cout << '\\n'; }
template <typename Head, typename... Tail> void p(Head head, Tail... tail) {
  std::cout << head << (sizeof...(tail) ? " " : "");
  p(tail...);
}
template <typename T> inline void pv(std::vector<T> &v) {
  for (ll i = 0, N = v.size(); i < N; i++)
    std::cout << v[i] << " \\n"[i == N - 1];
}
template <typename T> inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <typename T> inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
template <typename T> inline void uniq(std::vector<T> &v) {
  v.erase(std::unique(v.begin(), v.end()), v.end());
}

/*-----8<-----template-----8<-----*/
#define LOCAL_DEBUGDP
namespace debugdpdetail {
template <typename Tp, size_t N>
std::vector<Tp>
debugdp_impl(ll index, std::vector<Tp> &dp, std::vector<ll> &dpitemsize,
             typename std::enable_if<(N == 1), Tp const &>::type x) {
  std::vector<Tp> ans(dpitemsize[1], x);
  for (ll i = 0; i < dpitemsize[1]; i++)
    ans[i] = dp[i + index];
  return ans;
}
template <typename Tp, size_t N>
auto debugdp_impl(ll index, std::vector<Tp> &dp, std::vector<ll> &dpitemsize,
                  typename std::enable_if<(N > 1), Tp const &>::type x) {
  std::vector<decltype(debugdp_impl<Tp, N - 1>(index, dp, dpitemsize, x))> ans;
  for (ll i = 0, size = dpitemsize[N] / dpitemsize[N - 1]; i < size; i++) {
    ans.push_back(debugdp_impl<Tp, N - 1>(index + dpitemsize[N - 1] * i, dp,
                                          dpitemsize, x));
  }
  return ans;
}
} // namespace debugdpdetail
/*-----8<-----library-----8<-----*/

constexpr ll R_MAX = 3000;
constexpr ll C_MAX = 3000;
constexpr ll V_I_MAX = 1e9;

ll R, C, K;
vector<ll> r;
vector<ll> c;
vector<ll> v;

void solve() {
  cin >> R >> C >> K;
  r = vector<ll>(K);
  c = vector<ll>(K);
  v = vector<ll>(K);
  rep(i, K) {
    cin >> r[i] >> c[i] >> v[i];
    r[i]--, c[i]--;
  }

  vector<vector<pair<ll, ll>>> item(R);
  rep(i, K) { item[r[i]].push_back({c[i], v[i]}); }
  rep(i, R) sort(all(item[i]));
  // debug(item);

  using dptype = ll;
  ll dpeachsize[] = {R + 1, C + 1, 4};
  constexpr ll dpeacharrsize = extent<decltype(dpeachsize), 0>::value;
  vector<ll> dpitemsize(dpeacharrsize + 1, 1);
  for (ll i = 0; i < dpeacharrsize; ++i)
    dpitemsize[i + 1] = dpitemsize[i] * dpeachsize[dpeacharrsize - 1 - i];
  vector<dptype> dp(dpitemsize.back(), 0);
  vector<bool> checked(dpitemsize.back(), false);
  auto getindex = [&](auto &&...args) {
    assert(sizeof...(args) == dpeacharrsize);
    ll ans = 0, i = dpeacharrsize - 1;
    for (auto &&n : {args...})
      ans += dpitemsize[i] * n, --i;
    return ans;
  };
#if defined(LOCAL_DEV) && defined(LOCAL_DEBUGDP)
  [[maybe_unused]] auto debugdp_lambda = [&](vector<dptype> &v) {
    auto dp = debugdpdetail::debugdp_impl<dptype, dpeacharrsize>(
        0, v, dpitemsize, dptype(0));
    debug(dp);
  };
#define debugdp(v)                                                             \\
  do {                                                                         \\
    debugdp_lambda(v);                                                         \\
  } while (false)
#else
#define debugdp(...)                                                           \\
  do {                                                                         \\
  } while (false)
#endif
  auto f = [&](auto &&f, ll x, ll y, ll nokori) -> dptype {
    if (x >= R) {
      return 0;
    } //?????
    ll dparrindex = getindex(x, y, nokori);
    debug(x, y);
    if (checked[dparrindex])
      return dp[dparrindex];

    dptype ans = 0;

    if (nokori) {
      auto it = lower_bound(all(item[x]), pair<ll, ll>(y, 0),
                            [](const pair<ll, ll> &x, const pair<ll, ll> &y) {
                              return x.first < y.first;
                            });
      for (; it != item[x].end(); it++) {
        ll t = f(f, x, it->first + 1, nokori - 1) + it->second;
        ll s = f(f, x + 1, it->first, 3) + it->second;
        chmax(ans, t);
        chmax(ans, s);
      }
    }

    ll s = f(f, x + 1, y, 3);
    chmax(ans, s);

    checked[dparrindex] = true;
    return dp[dparrindex] = ans;
  };
  dptype ans = f(f, 0, 0, 3);
  debugdp(dp);

  debug(f(f, 1, 2, 2));

  cout << ans << '\\n';
}

// https://atcoder.jp/contests/abc175/tasks/abc175_e
signed main() {
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  // ll Q; cin >> Q; while(Q--)solve();
  solve();
  return 0;
}