DouKaku?

#include<iostream>
#include<vector>
#include<algorithm>

#define ALLOF(c) (c).begin(),(c).end()
#define DEBUG(c) cerr<<"> "<<#c<<" = "<<c<<endl;

using namespace std;

int main()
{
    int n,m; cin>>n>>m;
    
    vector<int> seq(n);
    for(int i=0;i<n;i++)
        cin>>seq[i];
    
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            seq.push_back(seq[i]+seq[j]);
    
    sort(ALLOF(seq));
    seq.erase(unique(ALLOF(seq)),seq.end());
    seq.erase(upper_bound(ALLOF(seq),m),seq.end());
    
    int res=seq.back();
    int j=seq.size()-1;
    for(int i=0;i<seq.size();i++)
    {
        for(;j>=i && seq[i]+seq[j]>res;j--)
        {
            if(seq[i]+seq[j]<=m)
            {
                res=seq[i]+seq[j];
                break;
            }
        }
    }
    
    cout<<res<<endl;
    
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>

typedef unsigned long ulong;

template <typename T>
void sort_and_unique(std::vector<T>& v)
{
    std::sort(v.begin(), v.end());

    v.erase(std::unique(v.begin(), v.end()), v.end());
}

int main()
{
    size_t N;

    ulong M;

    assert(std::cin);

    std::cin >> N >> M;

    assert(1 <= N && N <= 1000);

    assert(1 <= M && M <= 200000000);

    // allows 1 throw

    std::vector<ulong> s1(1, 0); // 0 point == no throw

    s1.reserve(N + 1);

    for (size_t i = 0; i < N; ++i)
    {
        ulong p;

        assert(std::cin);

        std::cin >> p;

        assert(1 <= p && p <= 100000000);

        if (p <= M)
        {
            s1.push_back(p);
        }
    }

    sort_and_unique(s1);

    // allows 2 throw

    std::vector<ulong> s2;

    s2.reserve(s1.size() * s1.size());

    for (size_t i = 0; i < s1.size(); ++i)
    {
        for (size_t j = 0; j < s1.size() && s1[i] + s1[j] <= M; ++j)
        {
            s2.push_back(s1[i] + s1[j]);
        }
    }

    sort_and_unique(s2);

    // allows 4 throw

    ulong max_point = 0;

    std::vector<ulong>::reverse_iterator rit = s2.rbegin();

    for (std::vector<ulong>::iterator it = s2.begin(); it != s2.end(); ++it)
    {
        while (rit != s2.rend() && *it + *rit > M)
        {
            ++rit;
        }

        if (rit == s2.rend())
        {
            break;
        }

        max_point = std::max(max_point, *it + *rit);
    }

    std::cout << max_point << std::endl;
}