Language: C++

//******* It's LEVI_17 ***************

#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;

#define ff first
#define ss second
#define MP make_pair
#define mset(x,a) memset(x,a,sizeof(x))
#define max3(x,y,z) max(x,max(y,z))
#define min3(x,y,z) min(x,min(y,z))
#define sqr(a) (a)*(a)
#define all(x) (x).begin(), (x).end()
#define f(i, n) for (int i = 0; i < n; i++)
#define f1(i, n) for (int i = 1; i <= n; i++)
#define loop(i,a,b) for (int i = a; i < b; i++)
#define bloop(i,a,b) for (int i = a ; i>=b;i--)
#define vvll vector<vector<ll>>  
#define vll vector<ll> 
#define pll pair<ll,ll>
#define vpll vector<pll>
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define cases ll t;cin >> t;while(t--)
#define rr return 0
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

#define deb(a)			std::cerr<<#a<<"="<<(a)<<"\n"
#define deb2(a,b)		std::cerr<<#a<<"="<<(a)<<", "<<#b<<"="<<(b)<<"\n"
#define deb3(a,b,c)		std::cerr<<#a<<"="<<(a)<<", "<<#b<<"="<<(b)<<", "<<#c<<"="<<(c)<<"\n"
const int MOD = 1000 * 1000 * 1000 + 7;

//syntax for priority queue
// max queue -> priority_queue<ll>
// min queue -> priority_queue<ll,vector<ll>,greater<ll>>

//##############################################################################################

ll getRes(ll wt[],ll val[],ll n,ll w)
{
    int mat[2][w+ 1];
    memset(mat, 0, sizeof(mat));

    // iterate through all items 
    int i = 0;
    while (i < n) // one by one traverse each element 
    {
        int j = 0; // traverse all weights j <= W 

        // if i is odd that mean till now we have odd 
        // number of elements so we store result in 1th 
        // indexed row 
        if (i % 2 != 0)
        {
            while (++j <= w) // check for each value 
            {
                if (wt[i] <= j) // include element 
                    mat[1][j] = max(val[i] + mat[0][j - wt[i]],
                        mat[0][j]);
                else           // exclude element 
                    mat[1][j] = mat[0][j];
            }

        }

        // if i is even that mean till now we have even number 
        // of elements so we store result in 0th indexed row 
        else
        {
            while (++j <= w)
            {
                if (wt[i] <= j)
                    mat[0][j] = max(val[i] + mat[1][j - wt[i]],
                        mat[1][j]);
                else
                    mat[0][j] = mat[1][j];
            }
        }
        i++;
    }

    // Return mat[0][W] if n is odd, else mat[1][W] 
    return (n % 2 != 0) ? mat[0][W] : mat[1][W];
}

void solve()
{
    ll n,w;
    cin >> n >> w;
    ll wt[n],val[n];
    f(i, n)
        cin >> wt[i] >> val[i];
   
    ll res = getRes(wt,val, n,w);
    cout << res << "\n";
}

//###############################################################################################

int main()
{
    fast;
    ll t = 1;
    //cin >> t;
    while (t--)
    {
        solve();
    }
    rr;
}


//Watashi wa tsuyoku modotte kimasu

Compiler output:
a.cc: In function 'll getRes(ll*, ll*, ll, ll)':
a.cc:61:36: error: no matching function for call to 'max(ll, int&)'
   61 |                     mat[1][j] = max(val[i] + mat[0][j - wt[i]],
      |                                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
   62 |                         mat[0][j]);
      |                         ~~~~~~~~~~  
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:3:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:61:36: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   61 |                     mat[1][j] = max(val[i] + mat[0][j - wt[i]],
      |                                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
   62 |                         mat[0][j]);
      |                         ~~~~~~~~~~  
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:61:36: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   61 |                     mat[1][j] = max(val[i] + mat[0][j - wt[i]],
      |                                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
   62 |                         mat[0][j]);
      |                         ~~~~~~~~~~  
a.cc:76:36: error: no matching function for call to 'max(ll, int&)'
   76 |                     mat[0][j] = max(val[i] + mat[1][j - wt[i]],
      |                                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
   77 |                         mat[1][j]);
      |                         ~~~~~~~~~~  
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:76:36: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   76 |                     mat[0][j] = max(val[i] + mat[1][j - wt[i]],
      |                                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
   77 |                         mat[1][j]);
      |                         ~~~~~~~~~~  
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:76:36: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   76 |                     mat[0][j] = max(val[i] + mat[1][j - wt[i]],
      |                                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
   77 |                         mat[1][j]);
      |                         ~~~~~~~~~~  
a.cc:86:34: error: 'W' was not declared in this scope
   86 |     return (n % 2 != 0) ? mat[0][W] : mat[1][W];
      |                                  ^