제출 #492216

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
492216		blue	모임들 (IOI18_meetings)	C++17	36 / 100	5566 ms	304848 KiB

meetings

#include "meetings.h"
#include <vector>
#include <algorithm>
#include <iostream>
#include <deque>
using namespace std;
 
using ll = long long;
using vll = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
#define sz(x) (int(x.size()))
 
const int mx = 750'000;
const ll INF = 1'000'000'000'000'000'000LL;
 
 
int N;
int Q;
 
vi H;
 
vi L, R;
vi M(mx);
vi peak_queries[mx];
 
vi HD;
 
vi lc, rc;
vi le, re;
vll ans;
 
 
 
 
 
 
 
 
 
 
struct segtree
{
    int l;
    int r;
    pii v;
 
    segtree* left = NULL;
    segtree* right = NULL;
 
 
    segtree()
    {
        ;
    }
 
    segtree(int L, int R, vi& Z)
    {
        l = L;
        r = R;
        if(l == r)
        {
            v = {Z[l], l};
        }
        else
        {
            int m = (l+r)/2;
            left = new segtree(l, m, Z);
            right = new segtree(m+1, r, Z);
            v = max(left->v, right->v);
        }
    }
 
    pii rangemax(int L, int R)
    {
        if(R < l || r < L) return {-1, -1};
        else if(L <= l && r <= R) return v;
        else return max(left->rangemax(L, R), right->rangemax(L, R));
    }
};
 
segtree ST;
 
vi subtree;
 
int build_tree(int l, int r)
{
    if(r < l) return -1;
    int m = ST.rangemax(l, r).second;
    lc[m] = build_tree(l, m-1);
    rc[m] = build_tree(m+1, r);
 
    if(lc[m] != -1) subtree[m] += subtree[lc[m]];
    if(rc[m] != -1) subtree[m] += subtree[rc[m]];
 
    return m;
}
 
 
struct seg
{
    int x1;
    ll y1;
 
    int x2;
    ll y2;
 
    ll get_slope()
    {
        if(x2 == x1) return 0;
        else return (y2-y1)/(x2-x1);
    }
};
 
struct func
{
    ll lp = 0;
    deque<seg> d;
 
    void inc(ll W)
    {
        lp += W;
    }
 
    void push_back(func& K)
    {
        for(seg k: K.d)
        {
            d.push_back(seg{k.x1, k.y1 + K.lp - lp, k.x2, k.y2 + K.lp - lp});
        }
    }
 
    void push_front(func& K)
    {
        reverse(K.d.begin(), K.d.end());
        for(seg k: K.d)
        {
            d.push_front(seg{k.x1, k.y1 + K.lp - lp, k.x2, k.y2 + K.lp - lp});
        }
    }
 
    void front_AP(ll a, ll sl)
    {
        int xf = d.front().x1;
        int xb = -1;
        while(!d.empty())
        {
            ll dy2 = d.front().y2 + lp;
            int dx2 = d.front().x2;
 
            ll dy1 = d.front().y1 + lp;
            int dx1 = d.front().x1;
 
 
            ll new_y2 = a + sl*(dx2 - xf);
            if(new_y2 > dy2) break;
            else if(a > dy1) break;
            else
            {
                xb = max(xb, d.front().x2);
                d.pop_front();
            }
        }
 
 
        if(!d.empty())
        {
            // cerr << "case X\n";
            ll dy1 = d.front().y1 + lp;
            ll dx1 = d.front().x1;
 
 
            ll new_y1 = a + sl*(dx1 - xf);
            if(new_y1 <= d[0].y1 + lp)
            {
                ll d_sl = (d[0].y2 - d[0].y1)/(d[0].x2 - d[0].x1);
                int lo = d[0].x1;
                int hi = d[0].x2;
                while(lo != hi)
                {
                    int mid = (lo+hi)/2 + 1;
                    ll mid_y = lp + d[0].y1 + (mid-d[0].x1)*d_sl;
 
                    ll new_y = a + sl*(mid - xf);
 
                    if(new_y <= mid_y)
                        lo = mid;
                    else
                        hi = mid-1;
                }
 
                xb = max(xb, lo);
 
                d[0].x1 = lo+1;
                d[0].y1 = d[0].y2 - (d[0].x2 - d[0].x1)*d_sl;
 
            }
        }
 
 
        if(xf <= xb)
        {
            d.push_front({xf, a - lp, xb, a+sl*(xb-xf) - lp});
        }
    }
};
 
 
 
vector<func*> F(mx);
 
 
void dfs(int u)
{
    if(u == -1) return;
 
    le[u] = re[u] = u;
 
    if(lc[u] != -1)
    {
        dfs(lc[u]);
        subtree[u] += subtree[lc[u]];
        le[u] = le[lc[u]];
    }
    if(rc[u] != -1)
    {
        dfs(rc[u]);
        subtree[u] += subtree[rc[u]];
        re[u] = re[rc[u]];
    }
 
    for(int q: peak_queries[u])
    {
        int lo = 0;
        int hi = sz(F[rc[u]]->d) - 1;
        while(lo != hi)
        {
            int mid = (lo+hi)/2;
            if(F[rc[u]]->d[mid].x2 < R[q])
                lo = mid+1;
            else
                hi = mid;
        }
 
        auto fr = F[rc[u]];
 
        ll right_ans = fr->lp + fr->d[lo].y1 + fr->d[lo].get_slope()*(R[q] - fr->d[lo].x1);
 
 
        ans[q] = min(ans[q], ll(H[u])*(u - L[q] + 1) + right_ans);
    }
 
    ll left_ct = 1;
    if(lc[u] != -1) left_ct += subtree[lc[u]];
 
 
 
    if(rc[u] != -1)
    {
 
            F[rc[u]]->inc(ll(H[u])*(u - le[u] + 1));
    }
 
 
    ll dp_u;
    if(lc[u] == -1)
    {
        dp_u = H[u];
    }
    else
    {
        dp_u = H[u] + F[lc[u]]->d.back().y2 + F[lc[u]]->lp;
    }
 
 
    func ths;
    ths.d.push_back(seg{u, dp_u, u, dp_u});
 
    if(rc[u] != -1)
    {
        F[rc[u]]->front_AP(dp_u + H[u], H[u]);
 
    }
 
    if(lc[u] == -1 && rc[u] == -1)
    {
        F[u]->push_back(ths);
    }
    else if(lc[u] == -1)
    {
        F[u] = F[rc[u]];
        F[u]->push_front(ths);
    }
    else if(rc[u] == -1)
    {
        F[u] = F[lc[u]];
        F[u]->push_back(ths);
    }
    else
    {
        if(subtree[rc[u]] >= subtree[lc[u]])
        {
            F[u] = F[rc[u]];
            F[u]->push_front(ths);
            F[u]->push_front(*F[lc[u]]);
            F[lc[u]]->d.clear();
        }
        else
        {
            F[u] = F[lc[u]];
            F[u]->push_back(ths);
            F[u]->push_back(*F[rc[u]]);
            F[rc[u]]->d.clear();
        }
    }
}
 
 
 
 
 
 
 
 
 
 
vll minimum_costs(vi H_, vi L_, vi R_)
{
    // for(int f: L_) cerr << "le = " << f << '\n';
//PART 1: PROCESS INPUT
    H = H_;
    L = L_;
    R = R_;
 
    N = sz(H);
    Q = sz(L);
 
    // cerr << "queries: \n";
    // for(int j = 0; j < Q; j++) cerr << L_[j] << ' ' << R_[j] << '\n';
 
 
//PART 2: DISCRETISE HEIGHTS
    HD = vi(N);
    vector<pii> P;
    for(int i = 0; i < N; i++) P.push_back({H[i], i});
    sort(P.begin(), P.end());
    int ct = 0;
    for(pii p:P)
    {
        ct++;
        HD[p.second] = ct;
    }
 
 
 
 
 
 
    // for(int j = 0; j < Q; j++) cerr << j << " : " << M[j] << '\n';
 
    ans = vll(Q, INF);
 
    for(int t = 0; t <= 1; t++)
    {
 
//PART 3: IDENTIFY PEAK OF EACH QUERY
        if(t == 1)
        {
            reverse(HD.begin(), HD.end());
            reverse(H.begin(), H.end());
            for(int j = 0; j < Q; j++)
            {
                L[j] = N-1 - L[j];
                R[j] = N-1 - R[j];
                swap(L[j], R[j]);
                M[j] = N-1 - M[j];
            }
        }
 
        for(int i = 0; i < N; i++)
        {
            peak_queries[i].clear();
        }
 
        ST = segtree(0, N-1, HD);
        for(int j = 0; j < Q; j++)
        {
            if(t == 0)
                M[j] = ST.rangemax(L[j], R[j]).second;
            if(M[j] == R[j])
            {
                ans[j] = min(ans[j], ll(H[M[j]])*(R[j] - L[j] + 1));
            }
            else
                peak_queries[M[j]].push_back(j);
        }
 
        lc = rc = vi(N, -1);
        le = vi(N, 1'000'000'000);
        re = vi(N, -1);
        subtree = vi(N, 1);
        int rt = build_tree(0, N-1);
 
        for(int i = 0; i < N; i++) F[i] = new func;
        dfs(rt);
    }
 
    return ans;
}

컴파일 시 표준 에러 (stderr) 메시지

meetings.cpp: In member function 'void func::front_AP(ll, ll)':
meetings.cpp:152:17: warning: unused variable 'dx1' [-Wunused-variable]
  152 |             int dx1 = d.front().x1;
      |                 ^~~
meetings.cpp:169:16: warning: unused variable 'dy1' [-Wunused-variable]
  169 |             ll dy1 = d.front().y1 + lp;
      |                ^~~

• Subtask 1: 4 / 4
• Subtask 2: 15 / 15
• Subtask 3: 17 / 17
• Subtask 4: 0 / 24
• Subtask 5: 0 / 40