Submission #753178

#	Time	Username	Problem	Language	Result	Execution time	Memory
753178		Olympia	K개의 묶음 (IZhO14_blocks)	C++17	53 / 100	1075 ms	1492 KiB

blocks

#include <vector>
#include <iostream>
#include <cassert>
#include <cmath>
#include <map>
#include <set>
using namespace std;
vector<int64_t> p;
struct SegmentTree {
    vector<int64_t> orig;
    vector<int64_t> vec;
    vector<int64_t> lazy;
    const int64_t INF = 1e18;
    void push (int dum, int tl, int tr) {
        if (lazy[dum] == -1) {
            return;
        }
        lazy[2 * dum + 1] = lazy[dum];
        lazy[2 * dum + 2] = lazy[dum];
        vec[2 * dum + 1] = lazy[dum] + orig[2 * dum + 1];
        vec[2 * dum + 2] = lazy[dum] + orig[2 * dum + 2];
        lazy[dum] = -1;
    }
    void upd (int dum, int tl, int tr, int l, int r, int64_t x) {
        if (tl >= l and tr <= r) {
            lazy[dum] = x;
            vec[dum] = orig[dum] + x;
            //cout << dum << " " << vec[dum] << endl;
            return;
        }
        if (tl > r or l > tr) {
            return;
        }
        push(dum, tl, tr);
        upd(2 * dum + 1, tl, (tl + tr)/2, l, r, x);
        upd(2 * dum + 2, (tl + tr)/2 + 1, tr, l, r, x);
        vec[dum] = min(vec[2 * dum + 1], vec[2 * dum + 2]);
    }
    int64_t query (int dum, int tl, int tr, int l, int r) {
        if (tl >= l and tr <= r) {
            //cout << "Q " << dum << " " << vec[dum] << endl;
            return vec[dum];
        }
        if (tl > r or l > tr) {
            return INF;
        }
        push(dum, tl, tr);
        return min(query(2 * dum + 1, tl, (tl + tr)/2, l, r), query(2 * dum + 2, (tl + tr)/2 + 1, tr, l, r));
    }
    void upd (int l, int r, int64_t x) {
        //cout << "UPDATE " << l << " " << r << " " << x << endl;
        upd(0, 0, (int)vec.size()/2 - 1, l, r, x);
    }
    int64_t query (int l, int r) {
        //cout << "QUERY " << l << " " << r << endl;
        return query(0, 0, (int)vec.size()/2 - 1, l, r);
    }
    void build (int dum, int tl, int tr) {
        if (tl == tr) {
            orig[dum] = p[tl];
            return;
        }
        build(2 * dum + 1, tl, (tl + tr)/2);
        build(2 * dum + 2, (tl + tr)/2 + 1, tr);
        orig[dum] = min(orig[2 * dum + 1], orig[2 * dum + 2]);
    }
    SegmentTree () {
        while (__builtin_popcount(p.size()) != 1) {
            p.push_back(0);
        }
        int n = p.size();
        orig.assign(2 * n, 0);
        lazy.assign(2 * n, -1);
        build(0, 0, n - 1);
        vec = orig;
    }
};
int main () {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    /*
    p = {(int64_t)1e17, 5, 5, 8, 8, 8};
    SegmentTree st;
    st.upd(0, 0, 5);
    st.upd(1, 1, 1);
    cout << st.query(0, 0);
     */

    int N, K;
    cin >> N >> K;
    int64_t arr[N];
    for (int i = 0; i < N; i++) {
        cin >> arr[i];
    }
    int64_t INF = 1e17;
    vector<int64_t> cur(N + 1);
    p.assign(N + 1, INF), cur.assign(N + 1, INF);
    for (int j = 1; j <= N; j++) {
        p[j] = ((j == 1) ? arr[0] : max(p[j - 1], arr[j - 1]));
    }
    for (int i = 2; i <= K; i++) {
        SegmentTree val;
        //cout << "GET " << val.query(0, 0) << endl;
        for (int j = 1; j <= N; j++) {
            if (j == 1) {
                cur[j] = INF;
                int64_t myMax = 0;
                for (int l = j - 1; l >= 0; l--) {
                    myMax = max(myMax, arr[l]);
                    cur[j] = min(cur[j], p[l] + myMax);
                    val.upd(l, l, myMax);
                }
            } else {
                cur[j] = INF;
                int64_t myMax = 0;
                for (int l = j - 1; l >= 0; l--) {
                    myMax = max(myMax, arr[l]);
                    if (myMax == arr[j - 1]) {
                        cur[j] = min(cur[j], p[l] + myMax);
                        val.upd(l, l, myMax);
                    } else {
                        //cout << l << " " << p[l] << " " << myMax << " " << val.query(l, l) << endl;
                        assert(p[l] + myMax == val.query(l, l));
                        cur[j] = min(cur[j], val.query(l, l));
                    }
                }
            }
        }
        swap(cur, p);
    }
    cout << p[N];

}

• Subtask 1: 14 / 14
• Subtask 2: 18 / 18
• Subtask 3: 21 / 21
• Subtask 4: 0 / 47