Submission #1289758

#	Time	Username	Problem	Language	Result	Execution time	Memory
1289758		MunkhErdene	Arranging Shoes (IOI19_shoes)	C++17	100 / 100	200 ms	142916 KiB

shoes

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define ff first
#define ss second
#define _ << " " <<
#define yes cout<<"YES\n"
#define no cout<<"NO\n"
#define ull unsigned long long
#define lll __int128
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define BlueCrowner ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
const ll mod = 1e9 + 7;
const ll mod1 = 998244353;
const ll naim = 1e9;
const ll max_bit = 60;
const ull tom = ULLONG_MAX;
const ll MAXN = 100005;
const ll LOG = 20;
const ll NAIM = 1e18;
const ll N = 2e6 + 5;
// ---------- GCD ----------
ll gcd(ll a, ll b) {
    while (b) {
        a %= b;
        swap(a, b);
    }
    return a;
}
// ---------- LCM ----------
ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
// ---------- Modular Exponentiation ----------
ll modpow(ll a, ll b, ll m = mod) {
    ll c = 1;
    a %= m;
    while (b > 0) {
        if (b & 1) c = c * a % m;
        a = a * a % m;
        b >>= 1;
    }
    return c;
}
// ---------- Modular Inverse (Fermat’s Little Theorem) ----------
ll modinv(ll a, ll m = mod) {
    return modpow(a, m - 2, m);
}
// ---------- Factorials and Inverse Factorials ----------
ll fact[N], invfact[N];
void pre_fact(ll n = N-1, ll m = mod) {
    fact[0] = 1;
    for (ll i = 1; i <= n; i++) fact[i] = fact[i-1] * i % m;
    invfact[n] = modinv(fact[n], m);
    for (ll i = n; i > 0; i--) invfact[i-1] = invfact[i] * i % m;
}
// ---------- nCr ----------
ll nCr(ll n, ll r, ll m = mod) {
    if (r < 0 || r > n) return 0;
    return fact[n] * invfact[r] % m * invfact[n-r] % m;
}
// ---------- Sieve of Eratosthenes ----------
vector<ll> primes;
bool is_prime[N];
void sieve(ll n = N-1) {
    fill(is_prime, is_prime + n + 1, true);
    is_prime[0] = is_prime[1] = false;
    for (ll i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            for (ll j = i * i; j <= n; j += i)
                is_prime[j] = false;
        }
    }
    for (ll i = 2; i <= n; i++)
        if (is_prime[i]) primes.pb(i);
}
//2 + 7 + 1 + 3 + 9
ll count_swaps(vector<int> S){
    ll n = S.size() / 2;
    set<ll> nums;
    for(auto &x : S) nums.insert(abs(x));
    vector<queue<ll>> posL(n + 1);
    vector<queue<ll>> posR(n + 1);
    FOR(i, 0, 2 * n){
        if(S[i] < 0) posL[-S[i]].push(i);
        else posR[S[i]].push(i);
    }
    struct BIT{
        ll n;
        vector<ll> sum;
        BIT(ll _n){
            n = _n;
            sum.assign(n + 1, 0ll);
        }
        void add(ll pos, ll val){
            for(ll i = pos; i <= n; i += i & -i) sum[i] += val;
        }
        void update(ll l, ll r, ll val){
            add(l, val);
            add(r + 1, -val);
        }
        ll query(ll pos){
            ll ans = 0;
            for(ll i = pos; i > 0; i -= i & -i) ans += sum[i];
            return ans;
        }
    };
    BIT bit(2 * n);
    ll ans = 0;
    vector<bool> used(2 * n, 0);
    FOR(i, 0, n * 2){
        ll x = abs(S[i]);
        if(posL[x].empty()) continue;
        ll topL = posL[x].front();
        ll topR = posR[x].front();
        if(used[i]) continue;
        posL[x].pop();
        posR[x].pop();
        used[topL] = 1;
        used[topR] = 1;
        
        if(topL > topR) {
            ans += topL - topR + bit.query(topL + 1) - bit.query(topR + 1);
            bit.update(topR + 1, topL, 1);
        }
        else {
            ans += topR - topL - 1 + bit.query(topR + 1) - bit.query(topL + 1);
            bit.update(topL + 2, topR, 1);
        }
    }
    return ans;
    // 3 + 2 + 1 + 7 + 11
    // 9 + 7 + 5 + 2 + 1 + 1
    // 15 + 13 + 0 + 3 + 3 + 1 + 1
}
/*void solve() {
    ll n; cin >> n;
    vector<int> S(n * 2);
    for(auto &x : S) cin >> x;
    cout << count_swaps(S) << '\n';
}
int main() {
    BlueCrowner;
    ll t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}*/

• Subtask 1: 10 / 10
• Subtask 2: 20 / 20
• Subtask 3: 20 / 20
• Subtask 4: 15 / 15
• Subtask 5: 20 / 20
• Subtask 6: 15 / 15