Problem p02603 (C++) — buggy submission, verdict: Runtime Error

#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
#if __has_include(<boost/stacktrace.hpp>)
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \\
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
#endif
#ifdef LOCAL_TEST
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
#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 << ")";
}
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()
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<-----*/
class Item {
public:
  ll value, weight, index;
  Item() {}
  Item(ll value, ll weight, ll index)
      : value(value), weight(weight), index(index) {}
};
ostream &operator<<(ostream &s, const Item &item) {
  s << "{ " << item.index << " : value = " << item.value
    << ", weight = " << item.weight << " }";
  return s;
}

class KnapsackBB {
public:
  // 商品一覧
  vector<Item> items;
  // 各商品の在庫数
  vector<ll> item_size;
  // 商品の種類数
  ll N;
  // ナップサックの容量
  ll W;
  // 現在探索している商品の選び方　used_items[i]=j -> i番目の商品をj個選択
  vector<ll> used_items;
  // 現時点で最適な商品の選び方　opt_items[i]=j -> i番目の商品をj個選択
  vector<ll> opt_items;
  // 現時点で最適な商品の選び方をしたときの価値合計
  ll opt_value = 0;

  KnapsackBB(vector<Item> &items, vector<ll> &item_size, ll W)
      : items(items), item_size(item_size), N(items.size()), W(W) {}

  // 分枝限定法で探索
  // index=index-1番目の商品までは選択が終わった、index番目からの商品はまだ調べてない
  // value=今のところの価値合計
  // weight=今のところの重さ合計
  void searchbb(ll index, ll value, ll weight) {
    // 全部調べ終わった
    if (index == N || items[index].value <= 0) {
      if (opt_value < value) {
        opt_items = used_items;
        opt_value = value;
      }
      return;
    }

    // 緩和問題を解く
    ll tmp_weight = weight;
    double tmp_value = value;
    for (ll i = index; i < N; i++) {
      ll size = (W - tmp_weight) / items[i].weight;
      if (item_size[i] > size) {
        // 重さの余りを詰める
        double sizedouble = (double)(W - tmp_weight) / items[i].weight;
        tmp_value += items[i].value * sizedouble;
        tmp_weight = W;
        break;
      } else if (item_size[i] == size &&
                 (W - tmp_weight) % items[i].weight == 0) {
        // 緩和問題の解が元の問題でも実現可能→暫定解として使えるかも
        tmp_value += items[i].value * size;
        if (opt_value < tmp_value) {
          opt_value = tmp_value;
          opt_items = used_items;
          for (ll j = index; j < i; j++) {
            opt_items[j] = item_size[j];
          }
          opt_items[i] = size;
        }
        return;
      } else {
        tmp_value += items[i].value * item_size[i];
        tmp_weight += items[i].weight * item_size[i];
      }
    }

    // 緩和問題ですら暫定解を超えられない→これ以上調査する意味がない
    if (tmp_value < opt_value) {
      return;
    }

    // 重量制限が許されれば、index番目をi個選ぶ場合で探索
    for (ll i = min(item_size[index], (W - weight) / items[index].weight);
         i >= 0; i--) {
      used_items[index] = i;
      searchbb(index + 1, value + (items[index].value * i),
               weight + (items[index].weight * i));
    }
  }

  ll search() {
    // 商品をコスパのよい順に並び替え
    sort(items.begin(), items.end(), [](const Item &x, const Item &y) {
      return ((double)x.value / x.weight) > ((double)y.value / y.weight);
    });

    // 暫定解として貪欲に選んでみる
    ll opt_weight = 0;
    opt_value = 0;
    opt_items.assign(N, 0);
    for (ll i = 0; i < N; i++) {
      if (items[i].value <= 0)
        break;
      ll size = (W - opt_weight) / items[i].weight;
      if (item_size[i] >= size) {
        opt_weight += items[i].weight * size;
        opt_value += items[i].value * size;
        opt_items[i] = size;
      } else {
        opt_weight += items[i].weight * item_size[i];
        opt_value += items[i].value * item_size[i];
        opt_items[i] = item_size[i];
      }
    }
    used_items.assign(N, 0);

    searchbb(0, 0, 0);
    return opt_value;
  }
};

/*-----8<-----library-----8<-----*/

constexpr ll N_MAX = 80;
constexpr ll A_I_MAX = 200;

ll N;
vector<ll> A;

void solve() {
  cin >> N;
  A = vector<ll>(N);
  rep(i, N) { cin >> A[i]; }

  ll W = 1000; // 1000;
  rep(i, N - 1) {
    if (A[i] < A[i + 1]) {
      ll t = W / A[i];
      ll s = (A[i + 1] - A[i]) * t;
      W += s;
    } else {
    }
  }

  cout << W << endl;
}

// https://atcoder.jp/contests/m-solutions2020/tasks/m_solutions2020_d
signed main() {
  solve();
  return 0;
}


Error: 0

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
#if __has_include(<boost/stacktrace.hpp>)
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION                                    \\
  / usr / local / opt / binutils / bin / addr2line
#define _GNU_SOURCE 1
#include <boost/stacktrace.hpp>
#endif
#ifdef LOCAL_TEST
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
#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 << ")";
}
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()
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<-----*/
class Item {
public:
  ll value, weight, index;
  Item() {}
  Item(ll value, ll weight, ll index)
      : value(value), weight(weight), index(index) {}
};
ostream &operator<<(ostream &s, const Item &item) {
  s << "{ " << item.index << " : value = " << item.value
    << ", weight = " << item.weight << " }";
  return s;
}

class KnapsackBB {
public:
  // 商品一覧
  vector<Item> items;
  // 各商品の在庫数
  vector<ll> item_size;
  // 商品の種類数
  ll N;
  // ナップサックの容量
  ll W;
  // 現在探索している商品の選び方　used_items[i]=j -> i番目の商品をj個選択
  vector<ll> used_items;
  // 現時点で最適な商品の選び方　opt_items[i]=j -> i番目の商品をj個選択
  vector<ll> opt_items;
  // 現時点で最適な商品の選び方をしたときの価値合計
  ll opt_value = 0;

  KnapsackBB(vector<Item> &items, vector<ll> &item_size, ll W)
      : items(items), item_size(item_size), N(items.size()), W(W) {}

  // 分枝限定法で探索
  // index=index-1番目の商品までは選択が終わった、index番目からの商品はまだ調べてない
  // value=今のところの価値合計
  // weight=今のところの重さ合計
  void searchbb(ll index, ll value, ll weight) {
    // 全部調べ終わった
    if (index == N || items[index].value <= 0) {
      if (opt_value < value) {
        opt_items = used_items;
        opt_value = value;
      }
      return;
    }

    // 緩和問題を解く
    ll tmp_weight = weight;
    double tmp_value = value;
    for (ll i = index; i < N; i++) {
      ll size = (W - tmp_weight) / items[i].weight;
      if (item_size[i] > size) {
        // 重さの余りを詰める
        double sizedouble = (double)(W - tmp_weight) / items[i].weight;
        tmp_value += items[i].value * sizedouble;
        tmp_weight = W;
        break;
      } else if (item_size[i] == size &&
                 (W - tmp_weight) % items[i].weight == 0) {
        // 緩和問題の解が元の問題でも実現可能→暫定解として使えるかも
        tmp_value += items[i].value * size;
        if (opt_value < tmp_value) {
          opt_value = tmp_value;
          opt_items = used_items;
          for (ll j = index; j < i; j++) {
            opt_items[j] = item_size[j];
          }
          opt_items[i] = size;
        }
        return;
      } else {
        tmp_value += items[i].value * item_size[i];
        tmp_weight += items[i].weight * item_size[i];
      }
    }

    // 緩和問題ですら暫定解を超えられない→これ以上調査する意味がない
    if (tmp_value < opt_value) {
      return;
    }

    // 重量制限が許されれば、index番目をi個選ぶ場合で探索
    for (ll i = min(item_size[index], (W - weight) / items[index].weight);
         i >= 0; i--) {
      used_items[index] = i;
      searchbb(index + 1, value + (items[index].value * i),
               weight + (items[index].weight * i));
    }
  }

  ll search() {
    // 商品をコスパのよい順に並び替え
    sort(items.begin(), items.end(), [](const Item &x, const Item &y) {
      return ((double)x.value / x.weight) > ((double)y.value / y.weight);
    });

    // 暫定解として貪欲に選んでみる
    ll opt_weight = 0;
    opt_value = 0;
    opt_items.assign(N, 0);
    for (ll i = 0; i < N; i++) {
      if (items[i].value <= 0)
        break;
      ll size = (W - opt_weight) / items[i].weight;
      if (item_size[i] >= size) {
        opt_weight += items[i].weight * size;
        opt_value += items[i].value * size;
        opt_items[i] = size;
      } else {
        opt_weight += items[i].weight * item_size[i];
        opt_value += items[i].value * item_size[i];
        opt_items[i] = item_size[i];
      }
    }
    used_items.assign(N, 0);

    searchbb(0, 0, 0);
    return opt_value;
  }
};

/*-----8<-----library-----8<-----*/

constexpr ll N_MAX = 80;
constexpr ll A_I_MAX = 200;

ll N;
vector<ll> A;

void solve() {
  cin >> N;
  A = vector<ll>(N);
  rep(i, N) { cin >> A[i]; }

  ll W = 1000; // 1000;
  /*
  vector<Item> items;
  rep(i,N-1){
          items.push_back(Item(A[i+1]-A[i], A[i], i));
  }
  */
  /*
  //Item(ll value, ll weight, ll index)
  items.push_back(Item(A[i+1]-A[i], A[i], 0));
  vector<ll> item_size(items.size(), INF);
  KnapsackBB knapsack(items, item_size, W);
  ll opt_value = knapsack.search();
  W+=opt_value;
  */
  vector<Item> items;
  rep(i, N - 1) items.push_back(Item(A[i + 1] - A[i], A[i], i));
  vector<vector<ll>> dp(N + 1, vector<ll>(1e6 + 1, 0));
  // rep(i,N-1){
  for (ll n = 0; n < N - 1; n++) {
    for (ll w = 0; w <= W; w++) {
      if (w < items[n].weight) { // 範囲外参照しないためのガードと考えても良い
        dp[n + 1][w] = dp[n][w];
      } else {
        // 商品の個数制限１つ
        // dp[n+1][w]=max(dp[n][w], dp[n][w-items[n].weight]+items[n].value);
        // 商品の個数制限なし
        // dp[n+1][w]=max(dp[n][w], dp[n+1][w-items[n].weight]+items[n].value);
        dp[n + 1][w] =
            max(0LL, dp[n + 1][w - items[n].weight] + items[n].value);
      }
    }
    W += dp[n + 1][W];
    debug(W);
  }
  debug(dp);
  //}

  cout << W << endl;
}

// https://atcoder.jp/contests/m-solutions2020/tasks/m_solutions2020_d
signed main() {
  solve();
  return 0;
}