Submission #898242

#	Time	Username	Problem	Language	Result	Execution time	Memory
898242		GrindMachine	Boarding Passes (BOI22_passes)	C++17	100 / 100	195 ms	27448 KiB

passes

#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

/*

how to solve for a single color (subtask 1)?
assume x guys come from left and y guys come from right (x+y = n)
it's optimal to send [1..x] from left and [x+1..n] from right
what would be the expected number of collisions?
just observe the left half
expected #of collisions = expected #of inversions = x*(x-1)/4
similarly for right half, expectation = y*(y-1)/4
optimal split point is x = n/2 (split the array evenly into 2 parts)

extend the observations to solve the harder subtasks
g <= 15, so bitmask dp intended?

dp[mask] = min ev if all the bits set in mask are placed
try to add a bit that is not present in mask
for each group that we try to add, iterate over all split points (note that some pref goes to the left and the rest of the suff goes to the right)
note that the order of the guys in the current group doesnt affect the #of collisions with the already placed groups
so for a given split, calculating the cost is easy
find the best split, and transition to next state
gets 60 points

how to optimize for 100 points?

notice that the function decreases until some point and then increases after that (didnt prove, but intuitive)
so we can use integer ternary search to optimize our solution for 100 points

*/

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

vector<ll> add_pref[15][15], add_suff[15][15];

void solve(int test_case)
{
    string s; cin >> s;
    ll n = sz(s);
    s = "$" + s;

    ll siz = 0;
    rep1(i,n){
        amax(siz,(ll)s[i]-'A'+1);
    }

    vector<ll> pos[siz];
    rep1(i,n) pos[s[i]-'A'].pb(i);

    vector<ll> pref(n+5);

    rep(x,siz){
        fill(all(pref),0);
        trav(i,pos[x]){
            pref[i]++;
        }

        rep1(i,n) pref[i] += pref[i-1];
        
        rep(y,siz){
            if(x == y) conts;

            ll sum1 = 0, sum2 = 0;            
            add_pref[x][y].pb(0);
            add_suff[x][y].pb(0);

            trav(i,pos[y]){
                sum1 += pref[i];
                sum2 += pref[n]-pref[i];
                add_pref[x][y].pb(sum1);
                add_suff[x][y].pb(sum2);
            }
        }
    }

    vector<ll> dp(1<<siz,inf2);
    dp[0] = 0;

    rep(mask,1<<siz){
        vector<ll> seated;
        rep(c,siz){
            if(mask&(1<<c)){
                seated.pb(c);
            }
        }

        rep(c,siz){
            if(mask&(1<<c)) conts;

            ll sizp = sz(pos[c]);
            
            auto f = [&](ll i){
                ll s1 = i, s2 = sizp-i;
                ll cost1 = 0, cost2 = 0;
                trav(d,seated){
                    cost1 += add_pref[d][c][i];
                    cost2 += add_suff[d][c].back()-add_suff[d][c][i];
                }

                ll cost = s1*(s1-1)+s2*(s2-1)+cost1*4+cost2*4;
                return cost;
            };

            ll l = 0, r = sizp;
            ll p = sizp;

            while(l <= r){
                ll mid = (l+r) >> 1;
                if(f(mid) <= f(mid+1)){
                    p = mid;
                    r = mid-1;
                }
                else{
                    l = mid+1;
                }
            }

            ll mn_cost = inf2;

            for(int i = max(p-5,0ll); i <= min(p+5,sizp); ++i){
                amin(mn_cost,f(i));
            }

            amin(dp[mask|(1<<c)],dp[mask]+mn_cost);
        }
    }

    ld ans = (ld)dp[(1<<siz)-1]/4;
    cout << fixed << setprecision(11);
    cout << ans << endl;
}

int main()
{
    fastio;

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

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

    return 0;
}

• Subtask 1: 5 / 5
• Subtask 2: 25 / 25
• Subtask 3: 30 / 30
• Subtask 4: 40 / 40