Submission #901319

#	Time	Username	Problem	Language	Result	Execution time	Memory
901319		nguyen31hoang08minh2003	Holding (COCI20_holding)	C++14	88 / 110	411 ms	262144 KiB

holding

#include <bits/stdc++.h>

template<class A, class B>
bool maximize(A &a, const B& b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template<class A, class B>
bool minimize(A &a, const B& b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

using namespace std;

constexpr int MAX_N = 105, MAX_K = 1E4 + 5, INF = 0X3F3F3F3F;

int N, L, R, K, A[MAX_N];
bool visited[MAX_N][MAX_N][MAX_K];
signed result = INF, minimum[MAX_N][MAX_N][MAX_K], leftCost[MAX_N][MAX_K], rightCost[MAX_N][MAX_K];

long long findRightOptimalCost(const int i, const int j, const int k) {
    if (k < 0)
        return INF;

    if (i > R)
        return 0;

    if (!visited[i][j][k]) {
        visited[i][j][k] = true;
        minimum[i][j][k] = findRightOptimalCost(i + 1, j, k) + A[i];
        if (j <= N) {
            const int d = j - i;
            minimize(minimum[i][j][k], findRightOptimalCost(i, j + 1, k));
            if (k >= d)
                minimize(minimum[i][j][k], findRightOptimalCost(i + 1, j + 1, k - d) + A[j]);
        }
    }
    return minimum[i][j][k];
}

long long findLeftOptimalCost(const int i, const int j, const int k) {
    if (k < 0)
        return INF;

    if (i < L)
        return 0;

    if (!visited[i][j][k]) {
        visited[i][j][k] = true;
        minimum[i][j][k] = findLeftOptimalCost(i - 1, j, k) + A[i];
        if (j >= 1) {
            const int d = i - j;
            minimize(minimum[i][j][k], findLeftOptimalCost(i, j - 1, k));
            if (k >= d)
                minimize(minimum[i][j][k], findLeftOptimalCost(i - 1, j - 1, k - d) + A[j]);
        }
    }
    return minimum[i][j][k];
}

signed main() {
    #ifdef LOCAL
    freopen("input.INP", "r", stdin);
    #endif // LOCAL

    cin.tie(0) -> sync_with_stdio(0);
    cout.tie(0);

    cin >> N >> L >> R >> K;

    for (int i = 1; i <= N; ++i)
        cin >> A[i];

    for (int i = L, k; i <= R; ++i)
        for (k = 0; k <= K; ++k)
            leftCost[i][k] = findLeftOptimalCost(i, L - 1, k);

    memset(visited, false, sizeof(visited));

    for (int i = L, k; i <= R; ++i)
        for (k = 0; k <= K; ++k)
            rightCost[i][k] = findRightOptimalCost(i, R + 1, k);

    minimize(result, min(leftCost[R][K], rightCost[L][K]));

    for (int i = L, k; i < R; ++i)
        for (k = 0; k <= K; ++k)
            minimize(result, leftCost[i][k] + rightCost[i + 1][K - k]);

    cout << result << '\n';

    return 0;
}

• Subtask 1: 22 / 22
• Subtask 2: 33 / 33
• Subtask 3: 33 / 33
• Subtask 4: 0 / 22