Language: C++

//#include <bits/stdc++.h>
#include<iostream>
#include<vector>
using namespace ::std;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
#define rep(i, n) for (lint i = 0; i < (lint)(n); i++)
#define irep(i) for (lint i = 0;; i++)
#define irep1(i) for (lint i = 1;; i++)
#define irep2(i) for (lint i = 2;; i++)
#define rrep(i, n) for (lint i = (lint)(n - 1); i > -1; i--)
#define rrepi(i, a, b) for (lint i = (lint)(b - 1); i > a - 1; i--)
#define repi(i, a, b) for (lint i = lint(a); i < lint(b); i++)
#define rep2(i, a, b, c) for (lint i = lint(a); i > lint(b); i += c)
#define all(x) (x).begin(), (x).end()
#define sl(c) (('a') <= (c) && (c) <= ('z'))
#define ll(c) (('A') <= (c) && (c) <= ('Z'))
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define PI 3.141592653589793
#define cout (cout << fixed << setprecision(15))
#define makeupper(t) (transform(all(t), t.begin(), ::toupper))
#define makelower(t) (transform(all(t), t.begin(), ::tolower))
#define dist(x1, y1, x2, y2) (pow(pow(x2 - x1, 2) + pow(y2 - y1, 2), 0.5))
#define NEXT_LINE \
    string junk;  \
    getline(cin, junk);
#define output(v)                                        \
    do                                                   \
    {                                                    \
        rep(i, v.size()) cout << (i ? " " : "") << v[i]; \
        cout << "\n";                                    \
    } while (0)
#define output2(v)                                                 \
    rep(i, v.size())                                               \
    {                                                              \
        rep(j, v[i].size()) { cout << (j ? " " : "") << v[i][j]; } \
        cout << "\n";                                              \
    }
#define INF 1LL << 60
#define IINF 1 << 30
#define LINF 9223372036854775807
#define MOD 998244353
vector<lint> dx = {-1, 1, 0, 0, 1, 1, -1, -1};
vector<lint> dy = {0, 0, -1, 1, 1, -1, 1, -1};
vector<lint> operator+(const vector<lint> &v1, const vector<lint> &v2)
{
    vector<lint> v(v1.size() + v2.size(), 0);
    rep(i, v1.size()) v[i] = v1[i];
    rep(i, v2.size()) v[i + v1.size()] = v2[i];
    return v;
}
inline lint sum(vector<lint> v)
{
    lint sum = 0;
    rep(i, v.size()) sum += v[i];
    return sum;
}
inline string replace(string str, string before, std::string after)
{
    string::size_type Pos(str.find(before));
    while (Pos != std::string::npos)
    {
        str.replace(Pos, before.length(), after);
        Pos = str.find(before, Pos + after.length());
    }
    return str;
}
inline vector<string> split(string s, string delim)
{
    vector<string> elems;
    s = replace(s, "#", "HASH");
    s = replace(s, delim, "#");
    stringstream ss(s);
    string item;
    while (getline(ss, item, '#'))
    {
        elems.push_back(replace(item, "HASH", "#"));
    }
    return elems;
}
inline vector<int> cross(vector<int> a, vector<int> b)
{
    return {a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]};
}
inline lint GCD(lint a, lint b) { return b ? GCD(b, a % b) : a; }
inline vector<lint> primeList(lint n)
{
    vector<bool> p(n + 1);
    vector<lint> list;
    repi(i, 1, n + 1) p[i] = true;
    repi(i, 2, sqrt(n) + 1)
    {
        if (p[i])
        {
            repi(j, 2, n / i + 1)
            {
                p[i * j] = false;
            }
        }
    }
    repi(i, 2, n + 1) if (p[i]) list.push_back(i);
    return list;
}
inline set<lint> primeSet(lint n)
{
    vector<bool> p(n + 1);
    set<lint> set;
    repi(i, 1, n + 1) p[i] = true;
    repi(i, 2, sqrt(n) + 1)
    {
        if (p[i])
        {
            repi(j, 2, n / i + 1)
            {
                p[i * j] = false;
            }
        }
    }
    repi(i, 2, n + 1) if (p[i]) set.insert(i);
    return set;
}
inline bool isPrime(int num)
{
    if (num < 2)
        return false;
    else if (num == 2)
        return true;
    else if (num % 2 == 0)
        return false;
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
            return false;
    }
    return true;
}
inline lint max(vector<lint> num)
{
    lint M = num[0];
    rep(i, num.size()) M = max(M, num[i]);
    return M;
}
inline lint min(vector<lint> num)
{
    lint M = num[0];
    rep(i, num.size()) M = min(M, num[i]);
    return M;
}
inline lint signal(lint val)
{
    if (val == 0)
        return 0;
    else
        return val / abs(val);
}
struct IVector2
{
    lint x, y;
};
bool operator<(const IVector2 &s, const IVector2 &t)
{
    return s.x == t.x ? s.y < t.y : s.x < t.x;
};
bool operator>(const IVector2 &s, const IVector2 &t)
{
    return s.x == t.x ? s.y > t.y : s.x > t.x;
};
struct IVector3
{
    lint x, y, z;
};
struct IVector4
{
    lint x, y, z, w;
};
template <typename... args>
struct dfs
{
public:
    queue<function<void(void)>> que;
    function<void(args..., dfs<args...> &)> func;
    void run()
    {
        while (!que.empty())
        {
            que.front()();
            que.pop();
        }
    }
    void push(args... arg)
    {
        que.push(bind(func, arg..., ref(*this)));
    }
    dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func)
    {
        push(init...);
        run();
    }
};
lint mod_pow(lint x, lint y, lint mod)
{
    if (y == 0)
        return 1;
    else if (y == 1)
        return x;
    else if (y % 2 == 1)
        return x * mod_pow(x, y - 1, mod) % mod;
    else
        return mod_pow(x, y / 2, mod) * mod_pow(x, y / 2, mod) % mod;
}
lint binary_search(function<bool(lint)> func)
{
    lint left = -1;
    lint right = IINF;
    while (right - left > 1)
    {
        lint mid = left + (right - left) / 2;
        if (func(mid))
            right = mid;
        else
            left = mid;
    }
    return right;
}

/*std::string RLE(string str)
    {
        string result = "";
        char cmp = str[0];
        lint cnt = 0;
        rep(i, str.length())
        {
            if (cmp == str[i])
            {
                cnt++;
            }
            else
            {
                result += cmp;
                result += cnt;
                cnt = 0;
                cmp = str[i];
            }
        }
    }*/

//////////////
int main (){
    lint N;
    lint W;
    vec weight(110);
    vec value(110);
    vector<vec> dp(N, vec(W, 0));
    cin >> N >> W;
    rep(i, N){
        cin >> weight[i] >> value[i];
    }
    rep(i, N){
        for(lint w = 0; w <= W; ++w){
            if(w -weight[i] >= 0){
                dp[i + 1][w] = max(dp[i + 1][w], dp[i][w - weight[i]] + value[i]);
            }
            else{
                dp[i + 1][w] = max(dp[i + 1][w], dp[i][w]);
            }
        }
    }
    cout << dp[N][W] << endl;
}



Compiler output:
a.cc: In function 'std::vector<std::__cxx11::basic_string<char> > split(std::string, std::string)':
a.cc:84:22: error: variable 'std::stringstream ss' has initializer but incomplete type
   84 |     stringstream ss(s);
      |                      ^
a.cc: In function 'std::vector<long long int> primeList(lint)':
a.cc:102:16: error: 'sqrt' was not declared in this scope
  102 |     repi(i, 2, sqrt(n) + 1)
      |                ^~~~
a.cc:23:55: note: in definition of macro 'repi'
   23 | #define repi(i, a, b) for (lint i = lint(a); i < lint(b); i++)
      |                                                       ^
a.cc: At global scope:
a.cc:115:8: error: 'set' does not name a type
  115 | inline set<lint> primeSet(lint n)
      |        ^~~
a.cc: In function 'bool isPrime(int)':
a.cc:141:22: error: 'sqrt' was not declared in this scope
  141 |     double sqrtNum = sqrt(num);
      |                      ^~~~
a.cc: At global scope:
a.cc:192:5: error: 'queue' does not name a type
  192 |     queue<function<void(void)>> que;
      |     ^~~~~
a.cc:193:5: error: 'function' does not name a type; did you mean 'union'?
  193 |     function<void(args..., dfs<args...> &)> func;
      |     ^~~~~~~~
      |     union
a.cc:206:23: error: 'function' has not been declared
  206 |     dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func)
      |                       ^~~~~~~~
a.cc:206:31: error: expected ',' or '...' before '<' token
  206 |     dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func)
      |                               ^
a.cc: In member function 'void dfs<args>::run()':
a.cc:196:17: error: 'que' was not declared in this scope
  196 |         while (!que.empty())
      |                 ^~~
a.cc: In member function 'void dfs<args>::push(args ...)':
a.cc:204:9: error: 'que' was not declared in this scope
  204 |         que.push(bind(func, arg..., ref(*this)));
      |         ^~~
a.cc:204:23: error: 'func' was not declared in this scope
  204 |         que.push(bind(func, arg..., ref(*this)));
      |                       ^~~~
a.cc: In constructor 'dfs<args>::dfs(args ..., int)':
a.cc:206:71: error: class 'dfs<args>' does not have any field named 'func'
  206 |     dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func)
      |                                                                       ^~~~
a.cc:206:76: error: 'func' was not declared in this scope
  206 |     dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func)
      |                                                                            ^~~~
a.cc: At global scope:
a.cc:223:20: error: 'function' was not declared in this scope
  223 | lint binary_search(function<bool(lint)> func)
      |                    ^~~~~~~~
a.cc:4:1: note: 'std::function' is defined in header '<functional>'; this is probably fixable by adding '#include <functional>'
    3 | #include<vector>
  +++ |+#include <functional>
    4 | using namespace ::std;
a.cc:223:29: error: expected primary-expression before 'bool'
  223 | lint binary_search(function<bool(lint)> func)
      |                             ^~~~
a.cc: In function 'int main()':
a.cc:31:32: error: 'setprecision' was not declared in this scope
   31 | #define cout (cout << fixed << setprecision(15))
      |                                ^~~~~~~~~~~~
a.cc:280:5: note: in expansion of macro 'cout'
  280 |     cout << dp[N][W] << endl;
      |     ^~~~
a.cc:4:1: note: 'std::setprecision' is defined in header '<iomanip>'; this is probably fixable by adding '#include <iomanip>'
    3 | #include<vector>
  +++ |+#include <iomanip>
    4 | using namespace ::std;