oj.uz

Submission #1066060

# Submission time Handle Problem Language Result Execution time Memory
1066060 2024-08-19T14:32:33 Z j_vdd16 Catfish Farm (IOI22_fish) C++17
23 / 100
 1000 ms 96452 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;

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

    // int res = 0;
    // for (auto [y, w] : fishes[x]) {
    //     if (y1 <= y && y < y2)
    //         res += w;
    // }

    // return res;

    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);
    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;
        }
    }

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

    vector<ll> maxBefore(N);
    vector<ll> maxBoth(N);

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

            continue;
        }

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

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

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

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

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

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

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

            for (const auto& [prevHeight, prevScore] : beforeDp.at(x - 1)) {
                counter++;
                int 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;

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

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

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

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

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

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

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

    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:37: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]
   37 |     if (x >= fishes.size() || y2 <= y1)
      |         ~~^~~~~~~~~~~~~~~~

Subtask #1
0 / 3.0

# Verdict Execution time Memory Grader output
1 Incorrect 139 ms 53408 KB 1st lines differ - on the 1st token, expected: '40313272768926', found: '2147442400'
2 Halted 0 ms 0 KB -

Subtask #2
0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 348 KB Output is correct
2 Execution timed out 1101 ms 44812 KB Time limit exceeded
3 Halted 0 ms 0 KB -

Subtask #3
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 26 ms 38952 KB Output is correct
2 Correct 27 ms 38448 KB Output is correct
3 Correct 53 ms 46612 KB Output is correct
4 Correct 49 ms 46120 KB Output is correct
5 Correct 89 ms 63016 KB Output is correct
6 Correct 81 ms 61944 KB Output is correct
7 Correct 85 ms 61480 KB Output is correct
8 Correct 79 ms 63016 KB Output is correct

Subtask #4
0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 0 ms 348 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Incorrect 1 ms 604 KB 1st lines differ - on the 1st token, expected: '216624184325', found: '171898408420'
10 Halted 0 ms 0 KB -

Subtask #5
0 / 21.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 0 ms 348 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Incorrect 1 ms 604 KB 1st lines differ - on the 1st token, expected: '216624184325', found: '171898408420'
10 Halted 0 ms 0 KB -

Subtask #6
0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 0 ms 348 KB Output is correct
4 Correct 0 ms 348 KB Output is correct
5 Correct 0 ms 348 KB Output is correct
6 Correct 0 ms 348 KB Output is correct
7 Correct 1 ms 348 KB Output is correct
8 Correct 0 ms 348 KB Output is correct
9 Incorrect 1 ms 604 KB 1st lines differ - on the 1st token, expected: '216624184325', found: '171898408420'
10 Halted 0 ms 0 KB -

Subtask #7
14.0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 26 ms 38952 KB Output is correct
2 Correct 27 ms 38448 KB Output is correct
3 Correct 53 ms 46612 KB Output is correct
4 Correct 49 ms 46120 KB Output is correct
5 Correct 89 ms 63016 KB Output is correct
6 Correct 81 ms 61944 KB Output is correct
7 Correct 85 ms 61480 KB Output is correct
8 Correct 79 ms 63016 KB Output is correct
9 Correct 93 ms 69412 KB Output is correct
10 Correct 74 ms 42428 KB Output is correct
11 Correct 160 ms 85288 KB Output is correct
12 Correct 1 ms 348 KB Output is correct
13 Correct 0 ms 348 KB Output is correct
14 Correct 0 ms 344 KB Output is correct
15 Correct 1 ms 348 KB Output is correct
16 Correct 0 ms 348 KB Output is correct
17 Correct 0 ms 348 KB Output is correct
18 Correct 29 ms 37824 KB Output is correct
19 Correct 30 ms 37912 KB Output is correct
20 Correct 29 ms 37172 KB Output is correct
21 Correct 31 ms 38872 KB Output is correct
22 Correct 110 ms 67372 KB Output is correct
23 Correct 211 ms 93736 KB Output is correct
24 Correct 187 ms 96452 KB Output is correct

Subtask #8
0 / 16.0

# Verdict Execution time Memory Grader output
1 Incorrect 139 ms 53408 KB 1st lines differ - on the 1st token, expected: '40313272768926', found: '2147442400'
2 Halted 0 ms 0 KB -