Submission #948052

#	Time	Username	Problem	Language	Result	Execution time	Memory
948052		GrindMachine	Hotel (CEOI11_hot)	C++17	100 / 100	529 ms	46432 KiB

hot

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef long long int ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL)
#define pb push_back
#define endl '\n'
#define sz(a) (int)a.size()
#define setbits(x) __builtin_popcountll(x)
#define ff first
#define ss second
#define conts continue
#define ceil2(x,y) ((x+y-1)/(y))
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define yes cout << "Yes" << endl
#define no cout << "No" << endl

#define rep(i,n) for(int i = 0; i < n; ++i)
#define rep1(i,n) for(int i = 1; i <= n; ++i)
#define rev(i,s,e) for(int i = s; i >= e; --i)
#define trav(i,a) for(auto &i : a)

template<typename T>
void amin(T &a, T b) {
    a = min(a,b);
}

template<typename T>
void amax(T &a, T b) {
    a = max(a,b);
}

#ifdef LOCAL
#include "debug.h"
#else
#define debug(x) 42
#endif

/*

sort all rooms by cap
sort all orders by cost
process orders in dec ord of cost

let the curr order be of the form (cost,cap)
over all active rooms with capacity >= cap, find the room with min cost => let this room be i
if the curr order is picked, then it's optimal to match it with the ith room
conversely, if the ith room is chosen, then it needs to be matched with the curr order
this is true because if the ith room is matched with an order that has smaller cost, then it could be matched with the curr order for a higher profit

finding the min cost over all active rooms on a range can be done efficiently using a segtree
once a room is paired up with an order, it needs to be deactivated (set room cost to inf) 
at the end, sort the profits in non-inc order and pick values as long as possible and it's profitable (pick at most k values, dont pick values < 0) 

*/

const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const int inf1 = int(1e9) + 5;
const ll inf2 = ll(1e18) + 5;

template<typename T>
struct segtree {
    // https://codeforces.com/blog/entry/18051

    /*=======================================================*/

    struct data {
        ll mn,ind;
    };

    data neutral = {inf2,-1};

    data merge(data &left, data &right) {
        data curr;

        if(left.mn <= right.mn) curr = left;
        else curr = right;
        
        return curr;
    }

    void create(int i, T v) {
        tr[i] = {v,i-n};
    }

    void modify(int i, T v) {
        tr[i] = {v,i-n};
    }

    /*=======================================================*/

    int n;
    vector<data> tr;

    segtree() {

    }

    segtree(int siz) {
        init(siz);
    }

    void init(int siz) {
        n = siz;
        tr.assign(2 * n, neutral);
    }

    void build(vector<T> &a, int siz) {
        rep(i, siz) create(i + n, a[i]);
        rev(i, n - 1, 1) tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
    }

    void pupd(int i, T v) {
        modify(i + n, v);
        for (i = (i + n) >> 1; i; i >>= 1) tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
    }

    data query(int l, int r) {
        data resl = neutral, resr = neutral;

        for (l += n, r += n; l <= r; l >>= 1, r >>= 1) {
            if (l & 1) resl = merge(resl, tr[l++]);
            if (!(r & 1)) resr = merge(tr[r--], resr);
        }

        return merge(resl, resr);
    }
};

void solve(int test_case)
{
    ll n,m,k; cin >> n >> m >> k;
    vector<pll> a(n+5), b(m+5);
    rep1(i,n){
        cin >> a[i].ss >> a[i].ff;
    }
    rep1(i,m){
        cin >> b[i].ff >> b[i].ss;
    }

    sort(a.begin()+1,a.begin()+n+1);
    sort(b.begin()+1,b.begin()+m+1);
    segtree<ll> st(n+5);
    rep1(i,n) st.pupd(i,a[i].ss);

    vector<ll> profits;

    rev(i,m,1){
        auto [cost,cap] = b[i];
        ll pos = lower_bound(a.begin()+1,a.begin()+n+1,make_pair(cap,-1ll))-a.begin();
        auto [mn,ind] = st.query(pos,n);
        if(ind != -1){
            profits.pb(cost-mn);
            st.pupd(ind,inf2);
        }
    }

    sort(rall(profits));
    ll ans = 0;

    rep(i,sz(profits)){
        if(i >= k) break;
        if(profits[i] < 0) break;
        ans += profits[i];
    }

    cout << ans << endl;
}

int main()
{
    fastio;

    int t = 1;
    // cin >> t;

    rep1(i, t) {
        solve(i);
    }

    return 0;
}

• Subtask 1: 10 / 10
• Subtask 2: 10 / 10
• Subtask 3: 10 / 10
• Subtask 4: 10 / 10
• Subtask 5: 10 / 10
• Subtask 6: 10 / 10
• Subtask 7: 10 / 10
• Subtask 8: 10 / 10
• Subtask 9: 10 / 10
• Subtask 10: 10 / 10