oj.uz

답안 #1066095

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
1066095 2024-08-19T15:01:48 Z j_vdd16 메기 농장 (IOI22_fish) C++17
40 / 100
 1000 ms 135468 KB 
#include "fish.h"

#include <algorithm>
#include <bitset>
#include <cstdint>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

#define ll long long
#define loop(X, N) for(int X = 0; X < (N); X++)
#define all(V) V.begin(), V.end()
#define rall(V) V.rbegin(), V.rend()

using namespace std;

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;

vector<vector<pair<int, ll>>> fishes;
vector<map<int, ll>> prefixWeight;
vector<ll> totals;

inline ll weightSum(int x, int y1, int y2) {
    if (x >= fishes.size() || y2 <= y1)
        return 0;

    auto it1 = prefixWeight[x].upper_bound(y2 - 1);
    auto it2 = prefixWeight[x].upper_bound(y1 - 1);
    ll res = (--it1)->second - (--it2)->second;
    //cout << x << ' ' << y1 << ' ' << y2 << " = " << res << endl;
    return res;
}

long long max_weights(signed N, signed M, vector<signed> X, std::vector<signed> Y, std::vector<signed> W) {
    fishes = vector<vector<pair<int, ll>>>(N);
    loop(i, M) {
        fishes[X[i]].push_back({Y[i], W[i]});
    }
    fishes.push_back({});

    prefixWeight = vector<map<int, ll>>(N + 1);
    totals = vector<ll>(N + 1);
    loop(x, N + 1) {
        sort(all(fishes[x]));

        ll total = 0;
        prefixWeight[x][-2] = 0;
        for (auto [y, w] : fishes[x]) {
            total += w;

            prefixWeight[x][y] = total;
        }

        totals[x] = total;
    }

    vector<map<int, ll>> beforeDp(N);
    vector<map<int, ll>> bothDp(N);

    vector<ll> maxBefore(N);
    vector<ll> maxBoth(N);
    vector<ll> maxBeforeMinCur(N), maxBeforeMinNext(N);

    //bestBefore, bestBeforeAndAfter
    int counter = 0;
    loop(x, N) {
        if (x == 0) {
            for (const auto& [y, w] : fishes[x + 1]) {
                int height = y + 1;
                bothDp[0][height] = weightSum(x + 1, 0, height);
                maxBoth[x] = max(maxBoth[x], bothDp[0][height]);

                maxBeforeMinCur[x] = max(maxBeforeMinCur[x], 0 - weightSum(x, 0, height));
            }

            beforeDp[0][0] = 0;
            maxBefore[0] = 0;

            continue;
        }

        ll bestBefore2 = 0;
        if (x >= 2) {
            bestBefore2 = maxBefore[x - 2];
        }
        if (x >= 3) {
            bestBefore2 = max(bestBefore2, maxBoth[x - 3]);
        }

        for (const auto& [y, w] : fishes.at(x - 1)) {
            int height = y + 1;
            ll& both = bothDp[x][height];
            ll& before = beforeDp[x][height];

            both = maxBeforeMinCur[x - 1] + weightSum(x - 1, 0, height);
            before = maxBeforeMinCur[x - 1] + weightSum(x - 1, 0, height);

            // for (const auto& [prevHeight, prevScore] : beforeDp.at(x - 1)) {
            //     counter++;
            //     //ll prevCur = weightSum(x - 1, prevHeight, height);
            //     ll prevCur = -weightSum(x - 1, 0, prevHeight);

            //     both = max(both, prevScore + prevCur);
            //     before = max(before, prevScore + prevCur);
            // }
            // both += weightSum(x - 1, 0, height);
            // before += weightSum(x - 1, 0, height);

            both = max(both, maxBeforeMinNext[x]);
            for (const auto& [prevY, prevScore] : bothDp.at(x - 1)) {
                counter++;
                if (prevY <= height) 
                    continue;

                ll prevCur = -weightSum(x, 0, height);
                both = max(both, prevScore + prevCur);
            }

            ll prevWeight = weightSum(x - 1, 0, height);
            both = max(both, bestBefore2 + prevWeight);

            before = max(before, bestBefore2 + prevWeight);
            
            maxBefore[x] = max(maxBefore[x], before);
            maxBeforeMinCur[x] = max(maxBeforeMinCur[x], before - weightSum(x, 0, height));
            maxBeforeMinNext[x] = max(maxBeforeMinNext[x], before - weightSum(x + 1, 0, height));
        }
        for (const auto& [y, w] : fishes.at(x + 1)) {
            int height = y + 1;
            ll& both = bothDp[x][height];

            both = LLONG_MIN;

            for (const auto& [prevHeight, prevScore] : beforeDp.at(x - 1)) {
                counter++;
                ll prevCur = weightSum(x - 1, prevHeight, height);

                both = max(both, prevScore + prevCur);
            }
            for (const auto& [prevY, prevScore] : bothDp.at(x - 1)) {
                counter++;
                if (prevY <= height) 
                    continue;

                ll prevCur = -weightSum(x, 0, height);
                both = max(both, prevScore + prevCur);
            }

            ll prevWeight = weightSum(x - 1, 0, height);
            both = max(both, bestBefore2 + prevWeight);
        }

        for (const auto& [height, score] : bothDp.at(x)) {
            counter++;
            ll nextWeight = weightSum(x + 1, 0, height);
            bothDp[x][height] += nextWeight;
            
            maxBoth[x] = max(maxBoth[x], bothDp[x][height]);
        }

        ll& both = bothDp[x][0];
        ll& before = beforeDp[x][0];

        both = max({ both, maxBefore[x - 1], bestBefore2 });
        before = max(before, both);

        maxBefore[x] = max(maxBefore[x], before);
        maxBoth[x] = max(maxBoth[x], both);

        maxBeforeMinCur[x] = max(maxBeforeMinCur[x], before);
        maxBeforeMinNext[x] = max(maxBeforeMinNext[x], before);
    }

    //cout << "Counter: " << counter << endl;

    ll res = 0;
    loop(x, N) {
        for (auto [y, score] : beforeDp[x]) {
            res = max(res, score);
        }
        for (auto [y, score] : bothDp[x]) {
            res = max(res, score);
        }
    }

    return res;
}

Compilation message

fish.cpp: In function 'long long int weightSum(int, int, int)':
fish.cpp:38:11: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<std::pair<int, long long int> > >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   38 |     if (x >= fishes.size() || y2 <= y1)
      |         ~~^~~~~~~~~~~~~~~~

Subtask #1
3.0 / 3.0

# 결과 실행 시간 메모리 Grader output
1 Correct 136 ms 55164 KB Output is correct
2 Correct 175 ms 63804 KB Output is correct
3 Correct 27 ms 39476 KB Output is correct
4 Correct 30 ms 39484 KB Output is correct
5 Correct 640 ms 132736 KB Output is correct
6 Correct 336 ms 135468 KB Output is correct

Subtask #2
0 / 6.0

# 결과 실행 시간 메모리 Grader output
1 Correct 0 ms 348 KB Output is correct
2 Execution timed out 1039 ms 48776 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #3
9.0 / 9.0

# 결과 실행 시간 메모리 Grader output
1 Correct 27 ms 39472 KB Output is correct
2 Correct 28 ms 39464 KB Output is correct
3 Correct 59 ms 49760 KB Output is correct
4 Correct 53 ms 49072 KB Output is correct
5 Correct 83 ms 65252 KB Output is correct
6 Correct 101 ms 64600 KB Output is correct
7 Correct 85 ms 65312 KB Output is correct
8 Correct 84 ms 65324 KB Output is correct

Subtask #4
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 1 ms 348 KB Output is correct
6 Correct 1 ms 348 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Correct 1 ms 616 KB Output is correct
10 Correct 2 ms 1116 KB Output is correct
11 Correct 1 ms 604 KB Output is correct
12 Correct 2 ms 860 KB Output is correct
13 Correct 0 ms 348 KB Output is correct
14 Correct 2 ms 604 KB Output is correct

Subtask #5
0 / 21.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 1 ms 348 KB Output is correct
6 Correct 1 ms 348 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Correct 1 ms 616 KB Output is correct
10 Correct 2 ms 1116 KB Output is correct
11 Correct 1 ms 604 KB Output is correct
12 Correct 2 ms 860 KB Output is correct
13 Correct 0 ms 348 KB Output is correct
14 Correct 2 ms 604 KB Output is correct
15 Correct 1 ms 604 KB Output is correct
16 Correct 15 ms 860 KB Output is correct
17 Correct 677 ms 12396 KB Output is correct
18 Correct 766 ms 12228 KB Output is correct
19 Correct 414 ms 12528 KB Output is correct
20 Correct 421 ms 11860 KB Output is correct
21 Correct 407 ms 11956 KB Output is correct
22 Execution timed out 1046 ms 19536 KB Time limit exceeded
23 Halted 0 ms 0 KB -

Subtask #6
0 / 17.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1 ms 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 1 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 1 ms 348 KB Output is correct
6 Correct 1 ms 348 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Correct 1 ms 616 KB Output is correct
10 Correct 2 ms 1116 KB Output is correct
11 Correct 1 ms 604 KB Output is correct
12 Correct 2 ms 860 KB Output is correct
13 Correct 0 ms 348 KB Output is correct
14 Correct 2 ms 604 KB Output is correct
15 Correct 1 ms 604 KB Output is correct
16 Correct 15 ms 860 KB Output is correct
17 Correct 677 ms 12396 KB Output is correct
18 Correct 766 ms 12228 KB Output is correct
19 Correct 414 ms 12528 KB Output is correct
20 Correct 421 ms 11860 KB Output is correct
21 Correct 407 ms 11956 KB Output is correct
22 Execution timed out 1046 ms 19536 KB Time limit exceeded
23 Halted 0 ms 0 KB -

Subtask #7
14.0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Correct 27 ms 39472 KB Output is correct
2 Correct 28 ms 39464 KB Output is correct
3 Correct 59 ms 49760 KB Output is correct
4 Correct 53 ms 49072 KB Output is correct
5 Correct 83 ms 65252 KB Output is correct
6 Correct 101 ms 64600 KB Output is correct
7 Correct 85 ms 65312 KB Output is correct
8 Correct 84 ms 65324 KB Output is correct
9 Correct 106 ms 71204 KB Output is correct
10 Correct 73 ms 45244 KB Output is correct
11 Correct 158 ms 90412 KB Output is correct
12 Correct 1 ms 344 KB Output is correct
13 Correct 0 ms 348 KB Output is correct
14 Correct 1 ms 440 KB Output is correct
15 Correct 1 ms 348 KB Output is correct
16 Correct 0 ms 348 KB Output is correct
17 Correct 1 ms 348 KB Output is correct
18 Correct 30 ms 39476 KB Output is correct
19 Correct 31 ms 39472 KB Output is correct
20 Correct 35 ms 39452 KB Output is correct
21 Correct 26 ms 39476 KB Output is correct
22 Correct 139 ms 71716 KB Output is correct
23 Correct 193 ms 99380 KB Output is correct
24 Correct 211 ms 101924 KB Output is correct

Subtask #8
0 / 16.0

# 결과 실행 시간 메모리 Grader output
1 Correct 136 ms 55164 KB Output is correct
2 Correct 175 ms 63804 KB Output is correct
3 Correct 27 ms 39476 KB Output is correct
4 Correct 30 ms 39484 KB Output is correct
5 Correct 640 ms 132736 KB Output is correct
6 Correct 336 ms 135468 KB Output is correct
7 Correct 0 ms 348 KB Output is correct
8 Execution timed out 1039 ms 48776 KB Time limit exceeded
9 Halted 0 ms 0 KB -