Submission #248710

#	Time	Username	Problem	Language	Result	Execution time	Memory
248710		MarcoMeijer	Wiring (IOI17_wiring)	C++14	0 / 100	1095 ms	39052 KiB

wiring

    #include "wiring.h"
    #include <bits/stdc++.h>
    using namespace std;

    //macros
    typedef long long ll;
    typedef pair<int, int> ii;
    typedef pair<ll, ll> lll;
    typedef tuple<int, int, int> iii;
    typedef vector<int> vi;
    typedef vector<ii> vii;
    typedef vector<iii> viii;
    typedef vector<ll> vll;
    typedef vector<lll> vlll;
    #define REP(a,b,c) for(int a=int(b); a<int(c); a++)
    #define RE(a,c) REP(a,0,c)
    #define RE1(a,c) REP(a,1,c+1)
    #define REI(a,b,c) REP(a,b,c+1)
    #define REV(a,b,c) for(int a=int(c-1); a>=int(b); a--)
    #define INF 1e18
    #define pb push_back
    #define fi first
    #define se second

    struct Seg {
        Seg() {};
        void resize(int size) {
            sz = size;
            SEG.assign(sz*4, 0);
            LAZY.assign(sz*4, 0);
        }
        void add(int i, int j, ll v, ll lazy=0, int p=0, int l=0, int r=-1) {
            if(r == -1) r=sz-1;
            SEG [p] += lazy;
            LAZY[p] += lazy;
            if(j < l || i > r) return;
            if(i <= l && j >= r) {
                SEG[p] += v;
                LAZY[p] += v;
                return;
            }
            int m =(l+r)/2;
            add(i,j,v,LAZY[p],p*2+1,l,m);
            add(i,j,v,LAZY[p],p*2+2,m+1,r);
            SEG[p] = min(SEG[p*2+1], SEG[p*2+2]);
            LAZY[p] = 0;
        }
        void set(int i, ll v, ll lazy=0, int p=0, int l=0, int r=-1) {
            if(r == -1) r=sz-1;
            SEG [p] += lazy;
            LAZY[p] += lazy;
            if(i < l || i > r) return;
            if(l == r) {
                SEG[p] = v;
                return;
            }
            int m=(l+r)/2;
            set(i,v,LAZY[p],p*2+1,l,m);
            set(i,v,LAZY[p],p*2+2,m+1,r);
            SEG[p] = min(SEG[p*2+1], SEG[p*2+2]);
            LAZY[p] = 0;
        }
        ll get(int i, int j, ll lazy=0, int p=0, int l=0, int r=-1) {
            if(r == -1) r=sz-1;
            SEG [p] += lazy;
            LAZY[p] += lazy;
            if(j < l || i > r) return INF;
            if(i <= l && j >= r) return SEG[p];
            int m =(l+r)/2;
            ll a=get(i,j,LAZY[p],p*2+1,l,m);
            ll b=get(i,j,LAZY[p],p*2+2,m+1,r);
            LAZY[p] = 0;
            return min(a, b);
        }

        vll SEG;
        vll LAZY;
        int sz;
    };

    const int MX = 6e5;

    priority_queue<ii, vii, greater<ii>> pq;
    int n[2], p[2], m=0;
    vi f[2];
    ll a[MX], b[MX], sm[MX];
    ll dp[MX], ch[MX];
    ll md[MX];
    ll ans=0;

    Seg seg[2];

    ll min_total_length(std::vector<int> R, std::vector<int> B) {
        f[0] = R; f[1] = B;
        RE(i,2) n[i] = f[i].size();

        // fill a and b
        RE(i,2) RE(j,n[i]) pq.push({f[i][j], i});
        while(!pq.empty()) {
            a[m] = pq.top().fi;
            b[m] = pq.top().se;
            pq.pop(); m++;
        }

        ch[0]=0; md[0]=0; sm[0]=0;
        REP(i,1,m) {
            md[i] = md[i-1];
            ch[i] = ch[i-1];
            sm[i] = sm[i-1] + a[i-1];
            if(b[i] != b[i-1]) ch[i]++, md[i]=i;
        }
        sm[m] = sm[m-1]+a[m-1];

        dp[0] = 0;
        RE(i,2) seg[i].resize(m+2);
        REP(i,1,m+1) {
            ll ed = i-1;
            ll mid = md[ed];
            ll bg = md[max(0ll,mid-1)];
            if(mid == ed) {
                REI(j,bg,mid) RE(k,2) seg[k].set(j,dp[j]);
                REP(i,bg,mid) RE(k,2) seg[k].add(bg,i,-a[i]);
                REP(j,bg,mid) seg[0].add(j,j,-a[mid  ]*j);
                REP(j,bg,mid) seg[1].add(j,j,-a[mid-1]*j);
            }
            dp[i] = INF;
            if(mid == 0) continue;
            ll switchJ = 2*mid-ed-1;
            REV(j,bg,mid+1) {
                ll cost = 0;
                REP(i,mid,ed+1) cost += a[i];
                ll left = mid-j;
                ll right = ed-mid+1;
                if(left > right) {
                    cost += a[mid  ]*switchJ;
                    dp[i] = min(dp[i], seg[0].get(j,j) + cost);
                } else {
                    cost += a[mid-1]*switchJ;
                    dp[i] = min(dp[i], seg[1].get(j,j) + cost);
                }
            }
        }

        return dp[m];
    }

• Subtask 1: 0 / 7
• Subtask 2: 0 / 13
• Subtask 3: 0 / 10
• Subtask 4: 0 / 25
• Subtask 5: 0 / 45