제출 #735741

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
735741		GrindMachine	Kralj (COCI16_kralj)	C++17	140 / 140	579 ms	72696 KiB

kralj

// Om Namah Shivaya

#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) 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

/*

refs:
edi
thread: https://codeforces.com/blog/entry/47677?#comment-320681


circular array problems: try to find some cutpoint and transform into linear array problem

find a pos m s.t for any given order, nobody crosses the edge m -> m+1

let cnt(i) = #of elves that are paired up with dwarf x

how to check if given pos m is good?
starting from every pos, we will try our best to create an overflow

following should hold for all pos x:

cnt(x) + cnt(x+1) + ... + cnt(m) <= #of indices in range [x,m] (note: +1 in circular array and range in circular array)
cnt(x) + cnt(x+1) + ... + cnt(m) - (#of indices in range [x,m]) <= 0

(cnt(x)-1) + (cnt(x+1)-1) + ... + (cnt(m)-1) <= 0

replace all cnt(x) with cnt(x)-1,
cnt(x) + cnt(x+1) + ... + cnt(m) <= 0

rewrite in terms of prefix sums
let p(i) = sum[cnt(x)], x <= i (no circular stuff here)

if x > m:
p(n) - p(x) + p(x) = p(n) = 0 (p(n) = 0 because there are n dwarves and n elves)

if x <= m:
p(m) - p(x-1) <= 0

dont care abt first condition cuz p(n) is always 0
we must pick m s.t 2nd condition is satisfied

we can do this by picking m that has min val of p(m), so subtracting it with any other p(x) value would always be <= 0

once m is picked, we can cut the array at point (m,m+1):

now run greedy algo:
consider dwarfs in increasing order of new indices
when considering dwarf, first add all elves that belong to this dwarf to the active set

then, assign the elf with smallest value that has power > power of this dwarf
if such an elf doesnt exist, then assign the elf with lowest power

(idk formal proof, but sounds somewhat convincing)

*/

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

void solve(int test_case)
{
    ll n; cin >> n;
    vector<ll> go(n + 5);
    rep1(i, n) cin >> go[i];

    vector<ll> a(n + 5), b(n + 5);
    rep1(i, n) cin >> a[i];
    rep1(i, n) cin >> b[i];

    vector<ll> cnt(n + 5);
    vector<ll> enter[n + 5];

    rep1(i, n) cnt[go[i]]++, enter[go[i]].pb(i);
    rep1(i, n) cnt[i]--;

    vector<ll> pref(n + 5);
    rep1(i, n) pref[i] = pref[i - 1] + cnt[i];

    ll m = min_element(pref.begin() + 1, pref.begin() + n + 1) - pref.begin();

    vector<ll> indices;
    for (int i = m + 1; i <= n; ++i) {
        indices.pb(i);
    }
    rep1(i, m) indices.pb(i);

    set<ll> st;
    ll ans = 0;

    trav(dwarf, indices) {
        trav(elf, enter[dwarf]) {
            st.insert(b[elf]);
        }

        auto it = st.upper_bound(a[dwarf]);
        if (it == st.end()) {
            assert(!st.empty());
            st.erase(st.begin());
        }
        else {
            ans++;
            st.erase(it);
        }
    }

    cout << ans << endl;
}

int main()
{
    fastio;

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

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

    return 0;
}

• Subtask 1: 140 / 140