Problem:
IOI 饅頭(IOI Manju)
Incredible Okashi Inc. は「途方もなくおいしいお菓子(incredible okashi)」を製作している会社である．ここでは略してIOI 社と呼ぶ．IOI 社は特製のIOI 饅頭を作ったので，それを販売することになった．IOI 社は$M$ 種類の饅頭を1 個ずつ作った．作られた$M$ 個の饅頭はすべて同じ大きさであるが，ひとつひとつ異なる味なので価格は様々であり，$i$ 番目$(1 \leq i \leq M)$ の饅頭の価格は$P_i$ 円である．
ところで，あなたはJust Odd Inventions 社を知っているだろうか？ この会社の業務は「ただ奇妙な発明(just odd inventions)」をすることである．ここでは略してJOI 社と呼ぶ．IOI 社は，饅頭を詰めるための高級な箱をJOI 社に発注することになった．JOI 社の製作する饅頭用の箱は$N$ 種類あり， $j$ 番目$(1 \leq j \leq N)$の箱は最大で$C_j$ 個の饅頭を詰められる大きさであり，販売価格は$E_j$ 円である．これらの$N$ 種類の箱のうちの何種類か(0 種類以上$N$ 種類以下) を1 個ずつ発注し，饅頭をそれらの箱に詰め分けてセットで販売することになった．各饅頭セットの価格は，それに含まれる饅頭の価格の合計である．
すべての饅頭セットが売れるとした場合，IOI 社が得ることができる利益の最大値はいくらだろうか．ここで利益とは，販売した饅頭セットの価格の合計から，発注した箱の価格の合計を引いた値である．なお，箱に詰めなかった饅頭については，IOI 社のスタッフがおいしくいただくため，利益には影響しないものとする．
課題
各饅頭の価格と，各箱の大きさと価格が与えられたとき，IOI 社が得ることができる利益の最大値を求めるプログラムを作成せよ．
入力
標準入力から以下のデータを読み込め．
1 行目には，整数 $M, N$ が空白を区切りとして書かれており，饅頭が $M$ 個，箱が $N$ 種類あることを表す．
続く $M$ 行のうちの $i$ 行目 $(1 \leq i \leq M)$ には，整数 $P_i$ が書かれており，$i$ 番目の饅頭の価格が $P_i$ 円であることを表す．
続く$N$ 行のうちの $j$ 行目 $(1 \leq j \leq N)$ には，整数 $C_j$, $E_j$ が空白を区切りとして書かれており， $j$ 番目の箱は最大で $C_j$ 個の饅頭を詰められる大きさであり，価格が $E_j$ 円であることを表す．
出力
標準出力に，IOI 社が得られる利益の最大値を円単位で表す整数を1 行で出力せよ．
制限
すべての入力データは以下の条件を満たす．
$1 \leq M \leq 10000$
$1 \leq N \leq 500$
$1 \leq P_i \leq 10000 (1 \leq i \leq M)$
$1 \leq C_j \leq 10000 (1 \leq j \leq N)$
$1 \leq E_j \leq 10000 (1 \leq j \leq N)$
入出力例
入力例 1
4 3
180
160
170
190
2 100
3 120
4 250
出力例 1
480
この例では，1 番目の箱(100 円) と2 番目の箱(120 円) を発注し，たとえば1 番目の箱に1 番目の饅頭と2 番目の饅頭を詰めて $180 + 160 = 340$ 円のセットとして販売，2 番目の箱に3 番目の饅頭と4 番目の饅頭を詰めて $170 + 190 = 360$ 円のセットとして販売すると，IOI 社の利益は $700 - 220 = 480$ 円となる．
入力例 2
2 2
1000
2000
1 6666
1 7777
出力例 2
0
この例では，利益を最大化するためには箱を全く買わないのがよい．
入力例 3
10 4
200
250
300
300
350
400
500
300
250
200
3 1400
2 500
2 600
1 900
出力例 3
450
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

code_snippet: #include <stdio.h>
#include <utility>
#include <math.h>
#include <algorithm>
using namespace std;

#define rep(i,n) for(int i=0; i < (n); i++)
const int INF = 1001001001; // 無限大の定義

int M, N;
int P[10002]; // 餅の価格
int C[502];   // 箱に入る餅の数
int E[502];   // 箱の価格
int dp[2][10002]; // DPテーブル：j個目の箱まででk個以上入るようにした時の箱の価格の合計最小値
int change = 1;   // 現在のDPテーブルの切り替えフラグ

int main() {
    // 入力の読み込み
    scanf("%d %d", &M, &N);
    rep(i, M) scanf("%d", &P[i]);
    rep(i, N) scanf("%d %d", &C[i], &E[i]);

    // 餅の価格を昇順にソート
    sort(P, P + M);

    // DPテーブルの初期化と更新
    rep(i, N + 1) {
        change = (bool)(change == 0);
        rep(j, M + 1) {
            if (i == 0) {
                // 初期条件
                dp[change][j] = INF;
                dp[change][0] = 0;
            } else {
                if (j == 0) {
                    dp[change][j] = 0;
                } else {
                    // 最小値の計算
                    dp[change][j] = min(dp[change == 0][j], dp[change == 0][max(0, j - C[i - 1])] + E[i - 1]);
                }
            }
        }
    }

    int ans = 0;
    // 詰めることができる最大の餅の値を計算
    rep(i, M + 1) { // もちを詰める個数
        int inin = 0;
        rep(j, i) {
            inin += P[M - j - 1]; // 価格の高い順に詰める
        }
        ans = max(ans, inin - dp[change][i]);
    }

    // 結果の出力
    printf("%d\n", ans);
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3104
final_rank: 5

code_snippet: #line 1 "/opt/library/template.hpp"
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using i64 = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using f128 = __float128;

template <class T>
constexpr T infty = 0;
template <>
constexpr int infty<int> = 1'000'001'000;
template <>
constexpr ll infty<ll> = ll(infty<int>) * infty<int> * 2;
template <>
constexpr u32 infty<u32> = infty<int>;
template <>
constexpr u64 infty<u64> = infty<ll>;
template <>
constexpr i128 infty<i128> = i128(infty<ll>) * infty<ll>;
template <>
constexpr double infty<double> = infty<ll>;
template <>
constexpr long double infty<long double> = infty<ll>;
#define inf infty<ll>

using pi = pair<ll, ll>;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vector<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <class T>
using vvvvvc = vector<vvvvc<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;

#define vv(type, name, h, ...) \
  vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define vvv(type, name, h, w, ...)   \
  vector<vector<vector<type>>> name( \
      h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)       \
  vector<vector<vector<vector<type>>>> name( \
      a, vector<vector<vector<type>>>(       \
             b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))

#define rep1(a) for (ll _ = 0; _ < (ll)(a); ++_)
#define rep2(i, a) for (ll i = 0; i < (ll)(a); ++i)
#define rep3(i, a, b) for (ll i = a; i < (ll)(b); ++i)
#define rep4(i, a, b, c) for (ll i = a; i < (ll)(b); i += (c))
#define rrep1(a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep2(i, a) for (ll i = (a)-1; i >= (ll)(0); --i)
#define rrep3(i, a, b) for (ll i = (b)-1; i >= (ll)(a); --i)
#define rrep4(i, a, b, c) for (ll i = (b)-1; i >= (ll)(a); i -= (c))
#define overload4(a, b, c, d, e, ...) e
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)

#define all(x) (x).begin(),(x).end()
#define len(x) (ll)(x.size())
#define elif else if
#define bit(x, i) (((x)>>(i))&1)

#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second

#define stoi stoll
#define abs llabs

#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define LB(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define UB(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define UNIQUE(x) \
  sort(all(x)), x.erase(unique(all(x)), x.end()), x.shrink_to_fit()

ll popcnt(ll x) { return __builtin_popcountll(x); }
ll popcnt(u64 x) { return __builtin_popcountll(x); }
ll popcnt_mod_2(ll x) { return __builtin_parityll(x); }
ll popcnt_mod_2(u64 x) { return __builtin_parityll(x); }
ll topbit(ll x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll topbit(u64 x) { return (x == 0 ? -1 : 63 - __builtin_clzll(x)); }
ll lowbit(ll x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }
ll lowbit(u64 x) { return (x == 0 ? -1 : __builtin_ctzll(x)); }

template <typename T>
T floor(T a, T b) {
  return a / b - (a % b && (a ^ b) < 0);
}
template <typename T>
T ceil(T x, T y) {
  return floor(x + y - 1, y);
}
template <typename T>
T bmod(T x, T y) {
  return x - y * floor(x, y);
}
template <typename T>
pair<T, T> divmod(T x, T y) {
  T q = floor(x, y);
  return {q, x - q * y};
}

template<typename T> T SUM(const vector<T> &A) {
  T s = 0; for (auto &&a: A) s += a;
  return s;
}

template <typename T>
T POP(queue<T> &que) {
  T a = que.front();
  que.pop();
  return a;
}
template <typename T>
T POP(deque<T> &que) {
  T a = que.front();
  que.pop_front();
  return a;
}
template <typename T>
T POP(pq<T> &que) {
  T a = que.top();
  que.pop();
  return a;
}
template <typename T>
T POP(pqg<T> &que) {
  T a = que.top();
  que.pop();
  return a;
}
template <typename T>
T POP(vc<T> &que) {
  T a = que.back();
  que.pop_back();
  return a;
}

template <typename F>
ll binary_search(F check, ll ok, ll ng, bool check_ok = true) {
  if (check_ok) assert(check(ok));
  while (abs(ok - ng) > 1) {
    auto x = (ng + ok) / 2;
    (check(x) ? ok : ng) = x;
  }
  return ok;
}
template <typename F>
f128 binary_search_real(F check, f128 ok, f128 ng, ll iter = 100) {
  rep(iter) {
    f128 x = (ok + ng) / 2;
    (check(x) ? ok : ng) = x;
  }
  return (ok + ng) / 2;
}

// ? は -1
vc<int> s_to_vi(const string &S, char first_char) {
  vc<int> A(S.size());
  rep(i, S.size()) { A[i] = (S[i] != '?' ? S[i] - first_char : -1); }
  return A;
}

template <typename T, typename U>
vc<T> cumsum(vc<U> &A, ll off = 1) {
  ll N = A.size();
  vc<T> B(N + 1);
  rep(i, N) { B[i + 1] = B[i] + A[i]; }
  if (off == 0) B.erase(B.begin());
  return B;
}

// stable sort
template <typename T>
vi argsort(const vector<T> &A) {
  vi ids(len(A));
  iota(all(ids), 0);
  sort(all(ids),
       [&](ll i, ll j) { return (A[i] == A[j] ? i < j : A[i] < A[j]); });
  return ids;
}

// A[I[0]], A[I[1]], ...
template <typename T>
vc<T> rearrange(const vc<T> &A, const vi &I) {
  vc<T> B(len(I));
  rep(i, len(I)) B[i] = A[I[i]];
  return B;
}

template<typename T> inline bool chmax(T &a, T b) {return ((a<b)?(a=b,true):(false));}
template<typename T> inline bool chmin(T &a, T b) {return ((a>b)?(a=b,true):(false));}

inline void wt(const char c) { cout << c; }
inline void wt(const string s) { cout << s; }
inline void wt(const char *s) { cout << s; }

template <typename T>
void wt_integer(T x) {
  if (x < 0) { cout << (i64)(x); }
  else { cout << (u64)(x); }
}
template <typename T>
void wt_real(T x) {
  cout << fixed << setprecision(15) << (long double)(x);
}

inline void wt(int x) { wt_integer(x); }
inline void wt(ll x) { wt_integer(x); }
inline void wt(i128 x) { wt_integer(x); }
inline void wt(u32 x) { wt_integer(x); }
inline void wt(u64 x) { wt_integer(x); }
inline void wt(u128 x) { wt_integer(x); }
inline void wt(double x) { wt_real(x); }
inline void wt(long double x) { wt_real(x); }
inline void wt(f128 x) { wt_real(x); }

template <class T, class U>
void wt(const pair<T, U> val) {
  wt(val.first); wt(' '); wt(val.second);
}
template <size_t N = 0, typename T>
void wt_tuple(const T t) {
  if constexpr (N < std::tuple_size<T>::value) {
    if constexpr (N > 0) { wt(' '); }
    const auto x = std::get<N>(t);
    wt(x);
    wt_tuple<N + 1>(t);
  }
}
template <class... T>
void wt(tuple<T...> tpl) {
  wt_tuple(tpl);
}
template <class T, size_t S>
void wt(const array<T, S> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}
template <class T>
void wt(const vector<T> val) {
  auto n = val.size();
  for (size_t i = 0; i < n; i++) {
    if (i) wt(' ');
    wt(val[i]);
  }
}

void print() { wt('\n'); }
template <class Head, class... Tail>
void print(Head &&head, Tail &&... tail) {
  wt(head);
  if (sizeof...(Tail)) wt(' ');
  print(forward<Tail>(tail)...);
}

void YES(bool t = 1) { print(t ? "YES" : "NO"); }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = 1) { print(t ? "Yes" : "No"); }
void No(bool t = 1) { Yes(!t); }
void yes(bool t = 1) { print(t ? "yes" : "no"); }
void no(bool t = 1) { yes(!t); }
void onez(bool t = 1) { print(t ? 1 : 0); }
#define endl '\n'
#define dump(x) {cerr << #x " = " << x << '\n';}
#line 2 "main.cpp"

int solve();
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  while (!solve()) {break;}
  return 0;
}

int solve() {
  ll M, N;
  cin >> M >> N;
  vi P(M), C(N), E(N);
  rep(i, M) cin >> P[i];
  rep(i, N) cin >> C[i] >> E[i];
  sort(all(P), greater<ll>());
  vv(ll, dp, N+1, M+1, inf);
  rep(j, 0, N+1) dp[j][0] = 0;
  rep(j, 1, N+1) {
    rep(x, 1, M+1) {
      dp[j][x] = min(dp[j-1][x], dp[j-1][max(x-C[j-1],0LL)]+E[j-1]);
    }
  }
  ll ans = 0;
  ll s = 0;
  rep(x, 1, M+1) {
    s += P[x-1];
    chmax(ans, s-dp[N][x]);
  }
  print(ans);
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 42420
final_rank: 10

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
#define all(A) A.begin(),A.end()
#define rep(i, n) for (ll i = 0; i < (ll) (n); i++)
template<class T>
bool chmax(T& p, T q, bool C = 1) {
    if (C == 0 && p == q) {
        return 1;
    }
    if (p < q) {
        p = q;
        return 1;
    }
    else {
        return 0;
    }
}

template<class T>
bool chmin(T& p, T q, bool C = 1) {
    if (C == 0 && p == q) {
        return 1;
    }
    if (p > q) {
        p = q;
        return 1;
    }
    else {
        return 0;
    }
}

ll modPow(long long a, long long n, long long p) {
    if (n == 0) return 1; // 0乗にも対応する場合
    if (n == 1) return a % p;
    if (n % 2 == 1) return (a * modPow(a, n - 1, p)) % p;
    long long t = modPow(a, n / 2, p);
    return (t * t) % p;
}


ll gcd(ll(a), ll(b)) {
    if (a == 0)return b;
    if (b == 0)return a;
    ll c = a;
    while (a % b != 0) {
        c = a % b;
        a = b;
        b = c;
    }
    return b;
}
ll sqrtz(ll N) {
    ll L = 0;
    ll R = sqrt(N) + 10000;
    while (abs(R - L) > 1) {
        ll mid = (R + L) / 2;
        if (mid * mid <= N)L = mid;
        else R = mid;
    }
    return L;

}





int main() {

    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    ll M,N;
    cin>>M>>N;
    vll P(M);
    rep(i,M)cin>>P[i];
    sort(all(P));
    reverse(all(P));
    vll SP(M+1,0);
    rep(i,M)SP[i+1]=SP[i]+P[i];

    vvll DP(N+1,vll(M+1,1e18));
    DP[0][0]=0;
    rep(i,N){
        ll C,E;
        cin>>C>>E;
        rep(j,M+1){
            chmin(DP[i+1][j],DP[i][j]);
            chmin(DP[i+1][min(j+C,M)],DP[i][j]+E);
        }
    }
    ll an=0;
    rep(i,M+1){
        chmax(an,SP[i]-DP[N][i]);
    }
    cout<<an<<endl;
}
accuracy: 1
time_ms: 20
memory_kb: 42420
final_rank: 12

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<string>
#include<iomanip>
#include<numeric>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<random>
#include<bitset>
#include<cassert>
using namespace std;
typedef long long ll;
const int mod=998244353;
const int dx[]={1,0,0,-1},dy[]={0,1,-1,0};
int dp[501][10001];
int main(){
	int m,n,p[10001],c[500],e[500];
	cin>>m>>n;
	for(int i=1;i<=m;i++)
		cin>>p[i];
	for(int i=0;i<n;i++)
		cin>>c[i]>>e[i];
	sort(p+1,p+m+1,greater<>());
	for(int i=1;i<=m;i++)
		p[i]+=p[i-1];
	for(int i=0;i<=n;i++)
		for(int j=0;j<=m;j++)
			dp[i][j]=-1e9;
	dp[0][0]=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<=m;j++){
			dp[i+1][j]=max(dp[i+1][j],dp[i][j]);
			dp[i+1][min(j+c[i],m)]=max(dp[i+1][min(j+c[i],m)],dp[i][j]+p[min(j+c[i],m)]-p[j]-e[i]);
		}
	}
	cout<<*max_element(dp[n],dp[n]+m+1)<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 23048
final_rank: 9

code_snippet: #include <bits/stdc++.h>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
typedef long long ll;
//typedef int ll;
typedef pair<ll, ll> P;
const long long INF = 1e12;
template <typename T>
void input_arr(vector<T>& A, ll N) {
	for (ll i = 0; i < N; i++) {
		cin >> A[i];
	}
}
template <typename T, typename Q>
void input_arr(vector<pair<T, Q>>& A, ll N) {
	for (ll i = 0; i < N; i++) {
		cin >> A[i].first >> A[i].second;
	}
}
template <typename T>
void input_arr(vector<vector<T>>& A, ll H, ll W) {
	for (ll i = 0; i < H; i++) {
		for (ll j = 0; j < W; j++) {
			cin >> A[i][j];
		}
	}
}
void solve() {
    ll N, M; cin >> N >> M;
    vector<ll>A(N); input_arr(A, N);
    sort(A.begin(), A.end(), greater<ll>());
    vector<ll>C(N + 1, 0);
    for (ll i = 1; i <= N; i++) {
        C[i] = C[i - 1] + A[i - 1];
    }
    vector<P>B(M); input_arr(B, M);
    sort(B.begin(), B.end());
    vector<vector<ll>>DP(M + 1, vector<ll>(20000, INF));
    DP[0][0] = 0;
    for (ll i = 1; i <= M; i++) {
        DP[i][0] = 0;
        for (ll j = 1; j <= N; j++) {
            DP[i][j] = min(DP[i - 1][j], DP[i - 1][max(j - B[i - 1].first, 0LL)] + B[i - 1].second);
        }
    }
    ll ans = 0;
    for (ll i = 0; i <= N; i++) {
        ans = max(ans, C[i] - DP[M][i]);
    }
    cout << ans << endl;
}
int main() {
    solve();
}
accuracy: 1
time_ms: 30
memory_kb: 83580
final_rank: 16

code_snippet: #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define drep(i,j,n) for(int i=0;i<(int)(n-1);i++)for(int j=i+1;j<(int)(n);j++)
#define trep(i,j,k,n) for(int i=0;i<(int)(n-2);i++)for(int j=i+1;j<(int)(n-1);j++)for(int k=j+1;k<(int)(n);k++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yes(ans) if(ans)printf("yes\n");else printf("no\n")
#define Yes(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YES(ans) if(ans)printf("YES\n");else printf("NO\n")
#define popcount(v) __builtin_popcount(v)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define vector3d(type,name,h,w,...) vector<vector<vector<type>>>name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))
using namespace std;
using ll = long long;
template<class T> using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
const int MOD=1000000007;
const int MOD2=998244353;
const int INF=1<<30;
const ll INF2=1LL<<60;
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T,class L>void scan(pair<T, L>& p){scan(p.first);scan(p.second);}
template<class T,class U,class V>void scan(tuple<T,U,V>& p){scan(get<0>(p));scan(get<1>(p));scan(get<2>(p));}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T,class L>void print(const pair<T, L>& p){print(p.first);putchar(' ');print(p.second);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll modinv(ll a, ll m) {ll b = m, u = 1, v = 0;while (b) {ll t = a / b;a -= t * b; swap(a, b);u -= t * v; swap(u, v);}u %= m;if (u < 0) u += m;return u;}
ll updivide(ll a,ll b){return (a+b-1)/b;}
template<class T> void chmax(T &a,const T b){if(b>a)a=b;}
template<class T> void chmin(T &a,const T b){if(b<a)a=b;}

//1次元累積和
template<class T> struct CumulativeSum1D{
    int _n;
    vector<T> Sumv;
    CumulativeSum1D(vector<T> a) : _n((int)a.size()+1),Sumv((int)a.size()+1){
        Sumv[0]=0;
        for(int i=1;i<_n;i++){
            Sumv[i]=Sumv[i-1]+a[i-1];
        }
    }
    T query(int l,int r){
        return Sumv[r]-Sumv[l];
    }
};

int main(){
    INT(m,n);
    vector<int> a(m);
    in(a);
    sort(rall(a));
    vector<array<int,2>> b(n);
    rep(i,n)in(b[i][0],b[i][1]);
    vector<int> dp(m+1,INF);
    dp[0]=0;
    rep(i,n){
        for(int j=m-1;j>=0;j--){
            chmin(dp[min(m,j+b[i][0])],dp[j]+b[i][1]);
        }
        for(int j=m;j>=1;j--){
            chmin(dp[j-1],dp[j]);
        }
    }
    CumulativeSum1D<int> sumv(a);
    int ans=0;
    for(int i=0;i<=m;i++){
        chmax(ans,sumv.query(0,i)-dp[i]);
    }
    out(ans);
}
accuracy: 1
time_ms: 10
memory_kb: 3760
final_rank: 4

code_snippet: #include<cstdio>
#include<functional>
#include<algorithm>
using namespace std;
int sum[10001]={0},mn[10001],dp[501][100001]={0};
int main(void)
{
	int m,n,p[10001],c[501],e[501],i,j,ans;
	scanf("%d%d",&m,&n);
	for(i=1;i<=m;i++){
		scanf("%d",&p[i]);
	}
	sort(p+1,p+m+1,greater<int>());
	for(i=1;i<=m;i++){
		sum[i]=sum[i-1]+p[i];
	}
	for(i=0;i<n;i++){
		scanf("%d%d",&c[i],&e[i]);
	}
	for(i=0;i<=n;i++){
		for(j=0;j<=m;j++){
			dp[i][j]=1000000000;
			mn[j]=1000000000;
		}
	}
	dp[0][0]=0;
	for(i=0;i<n;i++){
		for(j=0;j<m;j++){
			if(dp[i][j]!=1000000000){
				dp[i+1][j]=min(dp[i+1][j],dp[i][j]);
				if(j+c[i]>m){
					dp[i+1][m]=min(dp[i+1][m],dp[i][j]+e[i]);
				}
				else{
					dp[i+1][j+c[i]]=min(dp[i+1][j+c[i]],dp[i][j]+e[i]);
				}
			}
		}
	}
	for(i=0;i<=n;i++){
		for(j=0;j<=m;j++){
			mn[j]=min(mn[j],dp[i][j]);
		}
	}
	ans=0;
	for(i=1;i<=m;i++){
		for(j=i;j<=m;j++){
			ans=max(ans,sum[i]-mn[j]);
		}
	}
	printf("%d\n",ans);
	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 24496
final_rank: 13

code_snippet: #include<cstdio>
#include<functional>
#include<algorithm>
using namespace std;
int sum[10001]={0},mn[10001],dp[100001][501]={0};
int main(void)
{
	int m,n,p[10001],c[501],e[501],i,j,ans;
	scanf("%d%d",&m,&n);
	for(i=1;i<=m;i++){
		scanf("%d",&p[i]);
	}
	sort(p+1,p+m+1,greater<int>());
	for(i=1;i<=m;i++){
		sum[i]=sum[i-1]+p[i];
	}
	for(i=0;i<n;i++){
		scanf("%d%d",&c[i],&e[i]);
	}
	for(i=0;i<=n;i++){
		for(j=0;j<=m;j++){
			dp[i][j]=1000000000;
			mn[j]=1000000000;
		}
	}
	dp[0][0]=0;
	for(i=0;i<n;i++){
		for(j=0;j<m;j++){
			if(dp[i][j]!=1000000000){
				dp[i+1][j]=min(dp[i+1][j],dp[i][j]);
				if(j+c[i]>m){
					dp[i+1][m]=min(dp[i+1][m],dp[i][j]+e[i]);
				}
				else{
					dp[i+1][j+c[i]]=min(dp[i+1][j+c[i]],dp[i][j]+e[i]);
				}
			}
		}
	}
	for(i=0;i<=n;i++){
		for(j=0;j<=m;j++){
			mn[j]=min(mn[j],dp[i][j]);
		}
	}
	ans=0;
	for(i=1;i<=m;i++){
		for(j=i;j<=m;j++){
			ans=max(ans,sum[i]-mn[j]);
		}
	}
	printf("%d\n",ans);
	return 0;
}
accuracy: 0.15151515151515152
time_ms: 30
memory_kb: 2744
final_rank: 17

code_snippet: #include<bits/stdc++.h>
#define int long long
constexpr long long mod = 1000000007;
#define for0(i, n) for(int i = 0; i < (n); i++)
#define for1(i, n) for(int i = 1; i <= (n);i++)
#define puts(x) cout << (x) << "\n"
using namespace std;
int dp[33456], m, n, p[23456], c, e, ans, sum;
signed main() {
	for1(i, 33455)dp[i] = mod;
	cin >> m >> n;
	for0(i, m)cin >> p[i];
	while (n--) {
		cin >> c >> e;
		for (int i = 23001; i >= 0; i--)dp[i + c] = min(dp[i + c], dp[i] + e);
	}
	for (int i = 33432; i >= 0; i--)dp[i] = min(dp[i], dp[i + 1]);
	sort(p, p + m);
	for1(i, m) {
		sum += p[m - i];
		ans = max(ans, sum - dp[i]);
	}puts(ans);
}
accuracy: 1
time_ms: 10
memory_kb: 3476
final_rank: 3

code_snippet: #include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define rep(i, x) for(ll i = 0; i < x; i++)
#define rep2(i, x) for(ll i = 1; i <= x; i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
const ll INF = 1000000000;
const int intINF = 1000000000;
const ll mod = 1000000007;
const ll MOD = 998244353;
const ld pi = 3.141592653589793238;

signed main() {
	ll n, m; cin >> n >> m;
	vector<ll> price(n);
	rep(i, n) { cin >> price[i]; }
	sort(all(price)); reverse(all(price));
	vector<ll> ko(m), cost(m);
	rep(i, m) { cin >> ko[i] >> cost[i]; }
	vector<ll> mi(n + 1, INF);//i個の饅頭を取ったときに必要なboxcostの最小値
	vector<vector<ll>> dp(n + 1, vector<ll>(m));//boxどんだけ埋まってるか
	mi[0] = 0;
	rep2(i, n) {
		rep(j, m) {
			if (dp[max((ll)0, i - ko[j])][j] == 0) {//容量OKか？
				if (mi[max((ll)0, i - ko[j])] + cost[j] < mi[i]) {
					mi[i] = mi[max((ll)0, i - ko[j])] + cost[j];
					dp[i] = dp[max((ll)0, i - ko[j])]; dp[i][j] += min(i, ko[j]);
				}
			}
		}
	}
	ll sum = 0, ans = 0;
	rep(i, n) {
		sum += price[i];
		ans = max(ans, sum - mi[i + 1]);
		//cout << mi[i + 1] << endl;
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 42488
final_rank: 15

code_snippet: #include <bits/stdc++.h>

using namespace std;

int M, N;
vector<int> Price;
vector<pair<int, int> > BoxInfo;
int DpTotalOfBox[500][10001];
const int INF = 1000000000;

void solve() {
	int ans, curSum, curPrice;

	memset(DpTotalOfBox, 0, sizeof(DpTotalOfBox));
	for (int i = 0; i < N; ++i) {
		for (int j = 1; j <= M; ++j) {
			DpTotalOfBox[i][j] = INF;
		}
	}

	ans = 0;
	curPrice = BoxInfo[0].second;
	curSum = min(M, BoxInfo[0].first);
	for (int i = 1; i <= curSum; ++i) {
		DpTotalOfBox[0][i] = curPrice;
		ans = max(ans, Price[i - 1] - DpTotalOfBox[0][i]);
	}

	for (int i = 1; i < N; ++i) {
		curPrice = BoxInfo[i].second;
		curSum = BoxInfo[i].first;
		for (int j = 1; j <= M; ++j) {
			DpTotalOfBox[i][j] = min(DpTotalOfBox[i - 1][j], curPrice + DpTotalOfBox[i - 1][max(0, j - curSum)]);
			ans = max(ans, Price[j - 1] - DpTotalOfBox[i][j]);
		}
	}

	cout << ans << endl;
}

int main() {
	int p, sum;

	cin >> M >> N;
	for (int i = 0; i < M; ++i) {
		cin >> p;
		Price.push_back(p);
	}
	for (int i = 0; i < N; ++i) {
		cin >> sum >> p;
		BoxInfo.push_back({ sum,p });
	}
	sort(Price.begin(), Price.end(), greater<int>());
	for (int i = 1; i < M; ++i) {
		Price[i] += Price[i - 1];
	}
	solve();

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 22812
final_rank: 8

code_snippet: #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx")
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int (i)=0;i<(n);i++)
#define REP(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define MOD 1000000007
#define INF 1e18
#define fcout cout << fixed << setprecision(15)
#define int long long
#define endl "\n"
#define yorn(f) puts((f)?"Yes":"No")
#define YORN(f) puts((f)?"YES":"NO")
typedef long long ll;
typedef pair<int, int> P;
int gcd(int a,int b){return b?gcd(b,a%b):a;};
int lcm(int a,int b){return a/gcd(a,b)*b;};
int mod(int a,int b){return (a+b-1)/b;};
template<typename A, size_t N, typename T>
void Fill(A(&array)[N],const T &val){std::fill((T*)array,(T*)(array+N),val);}
template<class T>inline bool chmax(T& a,T b){if(a<b){a=b;return true;}return false;};
template<class T>inline bool chmin(T& a,T b){if(a>b){a=b;return true;}return false;};

int p[10010], c[550], e[550];
int m, n; // m: 饅頭の数, n: 箱の数

signed main() {
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(false);
	
	cin >> m >> n;
	rep(i, m) cin >> p[i];
	rep(i, n) cin >> c[i] >> e[i];

	sort(p, p+m, greater<>());
	vector<int> sum(m + 10, 0); // i個目まで取った時の利益
	rep(i, m) sum[i+1] = sum[i] + p[i];

	// dp[i]: i個以上入れられるよう箱を用意した時の最小コスト
	vector<int> dp(m + 10, 0);
	rep(i, m+1) dp[i] = INF;
	dp[0] = 0;

	rep(i, n) {
		for(int j = m; j >= 0; j--) {
			// c: 入れられる個数, e: 価格
			chmin(dp[j], dp[max(0LL, j - c[i])] + e[i]);
		}
	}

	int ans = 0;
	rep(i, m+1) {
		chmax(ans, sum[i] - dp[i]);
		//cout << sum[i] << " " << dp[i] << endl;
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3416
final_rank: 6

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;
using lint = long long int;
long long int INF = 1001001001001001LL;
int inf = 1000000007;
long long int MOD = 1000000007LL;
double PI = 3.1415926535897932;

template<typename T1,typename T2>inline void chmin(T1 &a,const T2 &b){if(a>b) a=b;}
template<typename T1,typename T2>inline void chmax(T1 &a,const T2 &b){if(a<b) a=b;}

#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()

/* do your best */

int main() {
  
  int m, n; cin >> m >> n;
  vector<lint> p(m);
  for (int i = 0; i < m; i++) {
    cin >> p[i];
  }
  vector<lint> c(n);
  vector<lint> e(n);
  for (int i = 0; i < n; i++) {
    cin >> c[i] >> e[i];
  }

  vector<vector<lint>> dp(n + 1, vector<lint> (m + 1, INF));
  dp[0][0] = 0; 

  for (int i = 0; i < n; i++) {
    for (int j = 0; j <= m; j++) {
      if (dp[i][j] == INF) continue;
      
      // not
      dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);

      // take
      lint nCap = min(j + c[i], (lint)m);
      dp[i + 1][nCap] = min(dp[i + 1][nCap], dp[i][j] + e[i]);
    }
  }

  sort(RALL(p));
  vector<lint> acc(m + 1, 0);
  for (int i = 1; i <= m; i++) {
    acc[i] = p[i - 1];
    acc[i] += acc[i - 1];
  }

  lint ans = 0;
  // 饅頭 i こ販売
  
  for (int i = 1; i <= m; i++) {
    lint cost = dp[n][i];
    lint score = acc[i];
    ans = max(ans, score - cost);
  }

  cout << ans << endl;


  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 42200
final_rank: 11

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define enld '\n'
#define rep(i,n) for(int i=0; i<(n); i++)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("Ofast")
constexpr ll INF = 1e18;
constexpr int inf = 1e9;
constexpr ll mod = 1000000007;
constexpr ll mod2 = 998244353;
const double PI = 3.1415926535897932384626433832795028841971;
const int dx[6] = {1, 0, -1, 0,1,1};
const int dy[6] = {0, 1, 0, -1,1,-1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
// ---------------------------------------------------------------------------

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int N,M;
    cin >> N >> M;
    vector<int> A(N);
    for(int i=0; i<N; i++) cin >> A[i];
    sort(A.begin(),A.end(),greater<int>());
    vector<P> d(M);
    for(int i=0; i<M; i++){
        cin >> d[i].first >> d[i].second;
    }
    vector<vector<ll>> dp(M+1, vector<ll> (N+1,inf));
    dp[0][0] = 0;
    for(int i=0; i<M; i++){
        for(int j=0; j<=N; j++){
            chmin(dp[i+1][j],dp[i][j]);
            chmin(dp[i+1][j],dp[i][max(0,j-d[i].first)]+d[i].second);
        }
    }
    // for(int i=0; i<=M; i++){
    //     for(int j=0; j<=N; j++){
    //         cout << dp[i][j] << " ";
    //     }
    //     cout << enld;
    // }
    ll ans = 0;
    ll sum = 0;
    for(int i=0; i<N; i++){
        sum += A[i];
        chmax(ans,sum-dp[M][i+1]);
    }
    cout << ans << enld;
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 42212
final_rank: 14

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int inf = 1e9;

int main(){
    int m,n;
    cin >> m >> n;
    vector<int> a(m);
    for(int i=0; i<m; i++){
        cin >> a[i];
    }
    sort(a.begin(), a.end(), greater<int>());
    for(int i=0; i<m-1; i++){
        a[i+1] += a[i];
    }

    vector<int> b(n),c(n);
    for(int i=0; i<n; i++){
        cin >> b[i] >> c[i];
    }
    vector<int> dp(m+1, inf);
    dp[0] = 0;
    for(int i=0; i<n; i++){
        for(int j=m; j>=0; j--){
            dp[j] = min(dp[j], dp[max(j-b[i], 0)]+c[i]);
        }
        for(int j=m; j>0; j--){
            dp[j-1] = min(dp[j-1], dp[j]);
        }
    }

    int ans = 0;
    for(int i=0; i<m; i++){
        ans = max(ans, a[i]-dp[i+1]);
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3252
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF=1LL<<60;
const int inf=1<<30;
const int mod=1e9+7;
const int MOD=998244353;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    ll m,n;cin >> m >> n;
    vector<bool> b(n);
    vector<ll> p(m),c(n),e(n);
    for(int i=0;i<m;i++){
        cin >> p[i];
    }
    sort(p.begin(),p.end(),greater<ll>());
    for(int i=0;i<n;i++){
        cin >> c[i] >> e[i];
    }
    vector<ll> dp(m+1,INF);
    dp[0]=0;
    for(int i=0;i<n;i++){
        vector<ll> t(m+1,INF);
        t[0]=0;
        for(int j=0;j<=m;j++){
            chmin(t[j],dp[j]);
            chmin(t[min(m,j+c[i])],dp[j]+e[i]);
        }
        for(int j=0;j<=m;j++){
            dp[j]=t[j];
        }
    }
    ll ans=0,sum=0;
    for(int i=0;i<m;i++){
        sum+=p[i];
        chmax(ans,sum-dp[i+1]);
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3352
final_rank: 2

code_snippet: #include<cstdio>
#include<algorithm>
#include<functional>
using namespace std;
int p[10002],c[502],e[502],flg[10002][502],cnt[10002][502],dp[10002][502],sum[10002];
int main(void)
{
	int m,n,i,j,mx,a;
	scanf("%d %d",&m,&n);
	for(i=1;i<=m;i++){
		scanf("%d",&p[i]);
	}
	for(i=1;i<m;i++){
		for(j=i+1;j<=m;j++){
			if(p[i]<p[j]){
				swap(p[i],p[j]);
			}
		}
	}
	p[0]=0;
	for(i=1;i<=n;i++){
		scanf("%d %d",&c[i],&e[i]);
	}
	c[0]=0;
	e[0]=0;
	for(i=0;i<=n;i++){
		for(j=0;j<=m;j++){
			dp[i][j]=0;
			flg[i][j]=0;
			cnt[i][j]=0;
		}
	}
	flg[0][0]=1;
	sum[0]=0;
	for(i=1;i<=m;i++){
		sum[i]=sum[i-1]+p[i];
	}
	for(i=0;i<n;i++){
		for(j=0;j<=m;j++){
			a=j+c[i+1];
			if(a>m){
				a=m;
			}
			if(flg[i][j]!=0){
				if(flg[i+1][j]==0){
					dp[i+1][j]=dp[i][j];
				}
				else{
					dp[i+1][j]=max(dp[i][j],dp[i+1][j]);
				}
				flg[i+1][j]=1;
				if(flg[i+1][a]==0){
					dp[i+1][a]=dp[i][j]+(sum[a]-sum[j])-e[i+1];
				}
				else{
					dp[i+1][a]=max(dp[i+1][a],dp[i][j]+(sum[a]-sum[j])-e[i+1]);
				}
				flg[i+1][a]=1;
			}
		}
	}
	mx=0;
	for(i=0;i<=n;i++){
		mx=max(mx,dp[i][m]);
	}
	for(i=0;i<=m;i++){
		mx=max(mx,dp[n][i]);
	}
	printf("%d\n",mx);
	return 0;
}
accuracy: 0.15151515151515152
time_ms: 120
memory_kb: 2920
final_rank: 18

code_snippet: #include<cstdio>
#include<algorithm>
#include<functional>
using namespace std;
int p[10003],c[503],e[503],flg[10003][503],cnt[10003][503],dp[10003][503];
int main(void)
{
	int m,n,i,j,MAX;
	scanf("%d %d",&m,&n);
	for(i=1;i<=m;i++){
		scanf("%d",&p[i]);
	}
	for(i=1;i<m;i++){
		for(j=i+1;j<=m;j++){
			if(p[i]<p[j]){
				swap(p[i],p[j]);
			}
		}
	}
	for(i=1;i<=n;i++){
		scanf("%d %d",&c[i],&e[i]);
	}
	for(i=0;i<=m;i++){
		for(j=0;j<=n;j++){
			dp[i][j]=0;
			flg[i][j]=0;
			cnt[i][j]=0;
		}
	}
	flg[0][0]=1;
	for(i=0;i<=m;i++){
		for(j=0;j<=n;j++){
			if(flg[i][j]!=0){
				if(cnt[i][j]>0&&i!=m){
					if(dp[i+1][j]<dp[i][j]+p[i+1]||dp[i+1][j]==0){
						cnt[i+1][j]=cnt[i][j]-1;
						dp[i+1][j]=dp[i][j]+p[i+1];
						flg[i+1][j]=1;
					}
				}
				if(cnt[i][j]==0){
					if(dp[i][j+1]<=dp[i][j]||dp[i][j+1]==0){
						if(j!=n){
							dp[i][j+1]=dp[i][j];
							cnt[i][j+1]=cnt[i][j];
							flg[i][j+1]=1;
						}	
					}
					if(dp[i+1][j+1]<dp[i][j]+(p[i+1]-e[j+1]||dp[i+1][j+1]==0)){
						if(i!=m&&j!=n){
							dp[i+1][j+1]=dp[i][j]+(p[i+1]-e[j+1]);
						    cnt[i+1][j+1]=c[j+1]-1;
						    flg[i+1][j+1]=1;
						}
					}
				}
			}
		}
	}
	MAX=0;
	for(i=0;i<=m;i++){
		for(j=0;j<=n;j++){
			MAX=max(MAX,dp[i][j]);
		}
	}
	printf("%d\n",MAX);
	return 0;
}
accuracy: 0.15151515151515152
time_ms: 130
memory_kb: 61676
final_rank: 20

code_snippet: #include<cstdio>
#include<algorithm>
#include<functional>
using namespace std;
int p[10002],c[502],e[502],flg[10002][502],cnt[10002][502],dp[10002][502];
int main(void)
{
	int m,n,i,j,MAX;
	scanf("%d %d",&m,&n);
	for(i=1;i<=m;i++){
		scanf("%d",&p[i]);
	}
	for(i=1;i<m;i++){
		for(j=i+1;j<=m;j++){
			if(p[i]<p[j]){
				swap(p[i],p[j]);
			}
		}
	}
	for(i=1;i<=n;i++){
		scanf("%d %d",&c[i],&e[i]);
	}
	for(i=0;i<=m;i++){
		for(j=0;j<=n;j++){
			dp[i][j]=0;
			flg[i][j]=0;
			cnt[i][j]=0;
		}
	}
	flg[0][0]=1;
	for(i=0;i<=m;i++){
		for(j=0;j<=n;j++){
			if(flg[i][j]!=0){
				if(cnt[i][j]>0&&i!=m){
					if(dp[i+1][j]<dp[i][j]+p[i+1]||dp[i+1][j]==0){
						cnt[i+1][j]=cnt[i][j]-1;
						dp[i+1][j]=dp[i][j]+p[i+1];
						flg[i+1][j]=1;
					}
				}
				if(cnt[i][j]==0){
					if(dp[i][j+1]<=dp[i][j]||dp[i][j+1]==0){
						if(j!=n){
							dp[i][j+1]=dp[i][j];
							cnt[i][j+1]=cnt[i][j];
							flg[i][j+1]=1;
						}	
					}
					if(dp[i+1][j+1]<dp[i][j]+(p[i+1]-e[j+1]||dp[i+1][j+1]==0)){
						if(i!=m&&j!=n){
							dp[i+1][j+1]=dp[i][j]+(p[i+1]-e[j+1]);
						    cnt[i+1][j+1]=c[j+1]-1;
						    flg[i+1][j+1]=1;
						}
					}
				}
			}
		}
	}
	MAX=0;
	for(i=0;i<=m;i++){
		for(j=0;j<=n;j++){
			MAX=max(MAX,dp[i][j]);
		}
	}
	printf("%d\n",MAX);
	return 0;
}
accuracy: 0.15151515151515152
time_ms: 130
memory_kb: 61468
final_rank: 19

code_snippet: #include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
#include<set>
#include<map>
#include<random>
#include<functional>
#include<utility>

typedef long long ll;

#define rep(i,n) for(int i=0; i<n; i++)
#define pb push_back
#define P pair<int, int>
#define PLI pair<ll, int>
#define PLL pair<ll, ll>
#define VI vector<int>
#define VII vector<VI>

using namespace std;


int M, N;
int p[10005], c[505], e[505];
int dp[505][10005] = {}, sum[10005] = {};
int main() {
	cin >> M >> N;
	rep(i, M) cin >> p[i];
	rep(i, N) cin >> c[i] >> e[i];
	sort(p, p + M, greater<>());
	rep(i, M) sum[i + 1] += sum[i] + p[i];
	for (int i = 0; i < N; i++) {
		for (int j = 0; j <= M; j++) {
			dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
			int tmp = min(j + c[i], M);
			dp[i + 1][tmp] = max(dp[i + 1][tmp], dp[i][j] + sum[tmp] - sum[j] - e[i]);
		}
	}
	int ans = 0;
	rep(i, M + 1) ans = max(ans, dp[N][i]);
	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 22792
final_rank: 7