Submission #916241

# Submission time Handle Problem Language Result Execution time Memory
916241 2024-01-25T14:17:37 Z Alcabel Split the sequence (APIO14_sequence) C++17
100 / 100
405 ms 86500 KB
#include <bits/stdc++.h>
using namespace std;

struct Line {
    long long a, b;
    int idx;
    Line() {}
    Line(long long _a, long long _b, int _idx) {
        a = _a, b = _b, idx = _idx;
    }
    long long f(int x) {
        return a * x + b;
    }
    ~Line() {}
};

int sign(long long x) {
    if (x > 0) { return 1; }
    if (x < 0) { return -1; }
    return 0;
}

long long intersect(const Line& A, const Line& B) {
    // A.a * x + A.b = B.a * x + B.b
    // x = (B.b - A.b) / (A.a - B.a)
    long long numer = B.b - A.b, denom = A.a - B.a;
    int sn = sign(numer), sd = sign(denom);
    numer *= sn, denom *= sd;
    if (sn * sd == -1) {
        return numer / denom * (-1);
    }
    return (numer + denom - 1) / denom;
}

const int inf = 2e9;

struct CHT {
    vector<long long> optX;
    vector<Line> lines;
    int ptr;
    CHT() {
        ptr = 0;
    }
    void clear() {
        optX.clear();
        lines.clear();
        ptr = 0;
    }
    void insert(const Line& l) {
        if (!lines.empty() && lines.back().a == l.a) {
            if (l.b >= lines.back().b) {
                return;
            }
            lines.pop_back();
            optX.pop_back();
        }
        while (!lines.empty() && intersect(lines.back(), l) <= optX.back()) {
            lines.pop_back();
            optX.pop_back();
        }
        if (!lines.empty()) {
            optX.emplace_back(intersect(lines.back(), l));
            lines.emplace_back(l);
        } else {
            optX.emplace_back(-inf);
            lines.emplace_back(l);
        }
    }
    pair<long long, int> getVal(int x) {
        ptr = min(ptr, (int)lines.size() - 1);
        while (ptr + 1 < (int)lines.size() && optX[ptr + 1] <= x) {
            ++ptr;
        }
        assert(ptr < (int)lines.size());
        return {lines[ptr].f(x), lines[ptr].idx};
    }
    ~CHT() {}
};

const int maxn = 1e5, maxk = 201;
int par[maxn][maxk];
long long dp[maxn][2];

void solve() {
    int n, k;
    cin >> n >> k;
    vector<int> a(n), pref(n + 1);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        pref[i + 1] = pref[i] + a[i];
    }
    int layer = 0;
    for (int i = 0; i < n; ++i) {
        dp[i][0] = pref[i + 1] * 1ll * pref[i + 1];
        par[i][0] = -1;
    }
    CHT cht;
    for (int g = 1; g <= k; ++g) {
        // cerr << "g: " << g << '\n';
        layer ^= 1;
        cht.clear();
        pair<long long, int> res;
        for (int i = g; i < n; ++i) {
            // cerr << "i: " << i << '\n';
            cht.insert(Line(-2 * pref[i], dp[i - 1][layer ^ 1] + pref[i] * 1ll * pref[i], i - 1));
            // cerr << "inserted!\n";
            res = cht.getVal(pref[i + 1]);
            // cerr << "got!\n";
            // cerr << "res: " << res.first + pref[i + 1] * 1ll * pref[i + 1] << '\n';
            dp[i][layer] = res.first + pref[i + 1] * 1ll * pref[i + 1];
            par[i][g] = res.second;
        }
    }
    cout << (pref[n] * 1ll * pref[n] - dp[n - 1][layer]) / 2 << '\n';
    vector<int> ans;
    for (int i = n - 1, j = k; i >= 0 && j > 0; i = par[i][j], --j) {
        // cerr << "i: " << i << '\n';
        // cerr << "par: " << par[i][j] << '\n';
        ans.emplace_back(par[i][j] + 1);
    }
    reverse(ans.begin(), ans.end());
    for (const int& x : ans) {
        cout << x << ' ';
    }
    cout << '\n';
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

#ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    int T = 1;
    cin >> T;
    while (T--) {
        solve();
        cerr << "-----------\n";
        cout << "-----------\n";
    }
#else
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
#endif

    return 0;
}
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2548 KB contestant found the optimal answer: 108 == 108
2 Correct 1 ms 2396 KB contestant found the optimal answer: 999 == 999
3 Correct 1 ms 2396 KB contestant found the optimal answer: 0 == 0
4 Correct 1 ms 2396 KB contestant found the optimal answer: 1542524 == 1542524
5 Correct 1 ms 2396 KB contestant found the optimal answer: 4500000000 == 4500000000
6 Correct 1 ms 2396 KB contestant found the optimal answer: 1 == 1
7 Correct 1 ms 2396 KB contestant found the optimal answer: 1 == 1
8 Correct 1 ms 2396 KB contestant found the optimal answer: 1 == 1
9 Correct 1 ms 2396 KB contestant found the optimal answer: 100400096 == 100400096
10 Correct 1 ms 2396 KB contestant found the optimal answer: 900320000 == 900320000
11 Correct 1 ms 2396 KB contestant found the optimal answer: 3698080248 == 3698080248
12 Correct 1 ms 2392 KB contestant found the optimal answer: 3200320000 == 3200320000
13 Correct 1 ms 2396 KB contestant found the optimal answer: 140072 == 140072
14 Correct 1 ms 2396 KB contestant found the optimal answer: 376041456 == 376041456
15 Correct 1 ms 2516 KB contestant found the optimal answer: 805 == 805
16 Correct 1 ms 2396 KB contestant found the optimal answer: 900189994 == 900189994
17 Correct 1 ms 2396 KB contestant found the optimal answer: 999919994 == 999919994
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2392 KB contestant found the optimal answer: 1093956 == 1093956
2 Correct 1 ms 2396 KB contestant found the optimal answer: 302460000 == 302460000
3 Correct 1 ms 2396 KB contestant found the optimal answer: 122453454361 == 122453454361
4 Correct 1 ms 2396 KB contestant found the optimal answer: 93663683509 == 93663683509
5 Correct 1 ms 2396 KB contestant found the optimal answer: 1005304678 == 1005304678
6 Correct 1 ms 2396 KB contestant found the optimal answer: 933702 == 933702
7 Correct 1 ms 2396 KB contestant found the optimal answer: 25082842857 == 25082842857
8 Correct 1 ms 2396 KB contestant found the optimal answer: 687136 == 687136
9 Correct 1 ms 2396 KB contestant found the optimal answer: 27295930079 == 27295930079
10 Correct 1 ms 2396 KB contestant found the optimal answer: 29000419931 == 29000419931
# Verdict Execution time Memory Grader output
1 Correct 1 ms 2392 KB contestant found the optimal answer: 610590000 == 610590000
2 Correct 1 ms 2392 KB contestant found the optimal answer: 311760000 == 311760000
3 Correct 1 ms 2392 KB contestant found the optimal answer: 1989216017013 == 1989216017013
4 Correct 1 ms 2516 KB contestant found the optimal answer: 1499437552673 == 1499437552673
5 Correct 1 ms 2508 KB contestant found the optimal answer: 1019625819 == 1019625819
6 Correct 1 ms 2396 KB contestant found the optimal answer: 107630884 == 107630884
7 Correct 1 ms 2396 KB contestant found the optimal answer: 475357671774 == 475357671774
8 Correct 1 ms 2396 KB contestant found the optimal answer: 193556962 == 193556962
9 Correct 1 ms 2392 KB contestant found the optimal answer: 482389919803 == 482389919803
10 Correct 1 ms 2396 KB contestant found the optimal answer: 490686959791 == 490686959791
# Verdict Execution time Memory Grader output
1 Correct 1 ms 4444 KB contestant found the optimal answer: 21503404 == 21503404
2 Correct 1 ms 4440 KB contestant found the optimal answer: 140412195 == 140412195
3 Correct 5 ms 4444 KB contestant found the optimal answer: 49729674225461 == 49729674225461
4 Correct 1 ms 4440 KB contestant found the optimal answer: 37485571387523 == 37485571387523
5 Correct 4 ms 4444 KB contestant found the optimal answer: 679388326 == 679388326
6 Correct 4 ms 4444 KB contestant found the optimal answer: 4699030287 == 4699030287
7 Correct 4 ms 4440 KB contestant found the optimal answer: 12418819758185 == 12418819758185
8 Correct 3 ms 4444 KB contestant found the optimal answer: 31093317350 == 31093317350
9 Correct 2 ms 4444 KB contestant found the optimal answer: 12194625429236 == 12194625429236
10 Correct 2 ms 4444 KB contestant found the optimal answer: 12345131038664 == 12345131038664
# Verdict Execution time Memory Grader output
1 Correct 3 ms 11320 KB contestant found the optimal answer: 1818678304 == 1818678304
2 Correct 3 ms 11320 KB contestant found the optimal answer: 1326260195 == 1326260195
3 Correct 28 ms 11572 KB contestant found the optimal answer: 4973126687469639 == 4973126687469639
4 Correct 4 ms 11576 KB contestant found the optimal answer: 3748491676694116 == 3748491676694116
5 Correct 25 ms 11320 KB contestant found the optimal answer: 1085432199 == 1085432199
6 Correct 27 ms 11320 KB contestant found the optimal answer: 514790755404 == 514790755404
7 Correct 29 ms 11572 KB contestant found the optimal answer: 1256105310476641 == 1256105310476641
8 Correct 20 ms 11576 KB contestant found the optimal answer: 3099592898816 == 3099592898816
9 Correct 25 ms 11576 KB contestant found the optimal answer: 1241131419367412 == 1241131419367412
10 Correct 29 ms 11828 KB contestant found the optimal answer: 1243084101967798 == 1243084101967798
# Verdict Execution time Memory Grader output
1 Correct 25 ms 85044 KB contestant found the optimal answer: 19795776960 == 19795776960
2 Correct 24 ms 85476 KB contestant found the optimal answer: 19874432173 == 19874432173
3 Correct 304 ms 86188 KB contestant found the optimal answer: 497313449256899208 == 497313449256899208
4 Correct 26 ms 86500 KB contestant found the optimal answer: 374850090734572421 == 374850090734572421
5 Correct 405 ms 85988 KB contestant found the optimal answer: 36183271951 == 36183271951
6 Correct 293 ms 85464 KB contestant found the optimal answer: 51629847150471 == 51629847150471
7 Correct 311 ms 86500 KB contestant found the optimal answer: 124074747024496432 == 124074747024496432
8 Correct 232 ms 85476 KB contestant found the optimal answer: 309959349080800 == 309959349080800
9 Correct 245 ms 85516 KB contestant found the optimal answer: 124113525649823701 == 124113525649823701
10 Correct 315 ms 85464 KB contestant found the optimal answer: 124309619349406845 == 124309619349406845