Submission #8531725

---

Source Code Expand

#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif

#define int long long
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
    sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = 1000000007;
template <class T>
bool chmax(T &a, const T &b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
template <class T>
bool chmin(T &a, const T &b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template <typename T>
vector<T> gen_v(size_t a) {
    return vector<T>(a);
}
template <typename T, typename... Ts>
auto gen_v(size_t a, Ts... ts) {
    return vector<decltype(gen_v<T>(ts...))>(a, gen_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
    t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
    for (auto &e : t) fill_v(e, v);
}

template <class T, class... Tail>
void tiedSort(vector<T> &a, vector<Tail> &... tail) {
    int n = a.size();
    using S = tuple<T, Tail...>;
    vector<S> s(n);
    for (int i = 0; i < n; i++) s[i] = make_tuple(a[i], tail[i]...);
    sort(s.begin(), s.end());
    for (int i = 0; i < n; i++) tie(a[i], tail[i]...) = s[i];
}

int solve(int N, int T, vector<int> A, vector<int> B) {
    tiedSort(A, B);
    reverse(all(A));
    reverse(all(B));
    int M = T + *max_element(all(A)) + 1;
    auto dp = gen_v<int>(M);
    fill_v(dp, -1);
    dp[0] = 0;

    rep(i, 0, N) {
        rrep(j, 0, T) {
            if (dp[j] == -1) continue;
            chmax(dp[j + A[i]], dp[j] + B[i]);
        }
    }
    dump(dp);
    return *max_element(all(dp));
}

signed main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    int N, T;
    cin >> N >> T;
    vector<int> A(N), B(N);
    rep(i, 0, N) { cin >> A[i] >> B[i]; }

    cout << solve(N, T, A, B) << endl;

    return 0;
}

Submission Info

Judge Result