oj.uz

Submission #906699

# Submission time Handle Problem Language Result Execution time Memory
906699 2024-01-14T18:53:47 Z vjudge1 Catfish Farm (IOI22_fish) C++17
9 / 100
 131 ms 17636 KB 
#include "fish.h"

#pragma GCC target ("avx2")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")

#include<bits/stdc++.h>
#include<math.h>
using namespace std;

typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
#define FD(i, r, l) for(ll i = r; i > (l); --i)

#define K first
#define V second
#define G(x) ll x; cin >> x;
#define GD(x) ld x; cin >> x;
#define GS(s) string s; cin >> s;
#define EX(x) { cout << x << '\n'; exit(0); }
#define A(a) (a).begin(), (a).end()
#define F(i, l, r) for (ll i = l; i < (r); ++i)

#define NN 310

ll grid[NN][NN];
ll n;

ll dp1[NN][NN];
ll noreq(ll, ll); // no request fishies, so len == prev wall. 

ll dp2[NN][NN];
ll req(ll, ll); 

// previous column did NOT request any right fishies here
// so we simply have a free wall to attach to 
ll noreq(ll i, ll len) {
    // assert(len == 0 or len == n);
    if (i == n) return 0;
    auto &DP = dp1[i][len];
    if (!~DP) {
        DP = noreq(i+1, n); // no restrictions so build big wall.

        F(nlen, 0, n+1) DP = max(DP, req(i, nlen)); // basically can set up any wall here before taking right fishes

        ll lsum = 0;
        F(j, 0, len) {
            lsum += grid[i][j];
        }
        DP = max(DP, lsum + noreq(i+1, 0));
        {
            ll tsum = lsum;
            F(j, 0, len) {
                tsum -= grid[i][j];
                DP = max(DP, tsum + noreq(i+1, j+1));
            }
        }


        F(covering, len, n) {
            // not lsum naymore jsut cum sum
            lsum += grid[i][covering];
            DP = max(DP, lsum + req(i+1, covering + 1));
        }

    }   
    return DP;   
}


// previous column requested right fishes here;
// so len == min bound on wall (we cannot take anything below len)

ll req(ll i, ll len) {
    if (i == n) return len == 0 ? 0 : -9e18; // i should need 0 fishes here
    auto &DP = dp2[i][len];
    if (!~DP) {
        // note that we cannot request any left fishes here.
        DP = noreq(i+1, n);  // if we don't request ANY fish here, just go up to max 

        ll sm = 0;
        F(covering, len, n) {
            sm += grid[i][covering];
            DP = max(DP, sm + req(i+1, covering + 1));
        }
    }   
    return DP;
}

long long max_weights(int N, int M, std::vector<int> X, std::vector<int> Y,
                      std::vector<int> W) {
    ll rans;

    if (N <= 300) {
        memset(dp1, -1, sizeof dp1);
        memset(dp2, -1, sizeof dp2);
        
        n = N;
        memset(grid, 0, sizeof grid);
        F(i, 0, M) grid[X[i]][Y[i]] = W[i];
        
        rans = noreq(0, 0);          
    }
    constexpr ll DEBUG = 01;
    if (N <= 300 and !DEBUG) return rans;

    bool case1 = 1;
    bool case2 = 1;
    bool case3 = 1;
    F(i, 0, M) case1 &= X[i]%2 == 0;
    F(i, 0, M) case2 &= X[i] <= 1;
    F(i, 0, M) case3 &= Y[i] == 0;
    
    if (case1) {
        return accumulate(A(W), 0ll);
    } else if (case2) {
        ll c[2] = {};
        map<pl, ll> points;
        F(i, 0, M) {
            c[X[i]] += W[i];
            points[{X[i], Y[i]}] = W[i];
        }
        
        if (N == 2) {
            return max(c[0], c[1]);
        }
        ll tans = max(c[0], c[1]);
        ll tsum = c[1];
        F(i, 0, N) {
            tsum -= points[{1, i}];
            tsum += points[{0, i}];
            tans = max(tans, tsum);
        }

        return tans;
    } else if (case3) {
        vl grid(n);
        F(i, 0, M) grid[X[i]] = W[i];
        vector<vl> dp(n+10, vl(3, -1));
        auto rec = [&](auto &&self, ll i, ll f) -> ll {
            if (i > n) return -1e18;
            if (i >= n) return 0;
            auto &DP = dp[i][f];
            if (!~DP) {
                DP = self(self, i+1, 1);
                if (f) DP = max(DP, grid[i] + self(self, i+1, 0));
                DP = max(DP, grid[i] + self(self, i+2, 1));
            }
            return DP;
        };
        // cout << rec(rec, 0, 0) << ' ' << rans << endl;
        // assert(rec(rec, 0, 0) == rans);
        return rec(rec, 0, 0);
    }

    return -1;
}

Subtask #1
3.0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 2168 KB Output is correct
2 Correct 22 ms 2660 KB Output is correct
3 Correct 0 ms 344 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 71 ms 7252 KB Output is correct
6 Correct 72 ms 7276 KB Output is correct

Subtask #2
6.0 / 6.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 2652 KB Output is correct
2 Correct 108 ms 15388 KB Output is correct
3 Correct 131 ms 17636 KB Output is correct
4 Correct 18 ms 2172 KB Output is correct
5 Correct 25 ms 2636 KB Output is correct
6 Correct 1 ms 2652 KB Output is correct
7 Correct 1 ms 2652 KB Output is correct
8 Correct 2 ms 2652 KB Output is correct
9 Correct 1 ms 2652 KB Output is correct
10 Correct 1 ms 344 KB Output is correct
11 Correct 0 ms 348 KB Output is correct
12 Correct 74 ms 13376 KB Output is correct
13 Correct 87 ms 15188 KB Output is correct
14 Correct 70 ms 13620 KB Output is correct
15 Correct 81 ms 15080 KB Output is correct
16 Correct 65 ms 13392 KB Output is correct
17 Correct 90 ms 14892 KB Output is correct

Subtask #3
0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Runtime error 1 ms 344 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #4
0 / 14.0

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

Subtask #5
0 / 21.0

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

Subtask #6
0 / 17.0

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

Subtask #7
0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Runtime error 1 ms 344 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #8
0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 18 ms 2168 KB Output is correct
2 Correct 22 ms 2660 KB Output is correct
3 Correct 0 ms 344 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 71 ms 7252 KB Output is correct
6 Correct 72 ms 7276 KB Output is correct
7 Correct 1 ms 2652 KB Output is correct
8 Correct 108 ms 15388 KB Output is correct
9 Correct 131 ms 17636 KB Output is correct
10 Correct 18 ms 2172 KB Output is correct
11 Correct 25 ms 2636 KB Output is correct
12 Correct 1 ms 2652 KB Output is correct
13 Correct 1 ms 2652 KB Output is correct
14 Correct 2 ms 2652 KB Output is correct
15 Correct 1 ms 2652 KB Output is correct
16 Correct 1 ms 344 KB Output is correct
17 Correct 0 ms 348 KB Output is correct
18 Correct 74 ms 13376 KB Output is correct
19 Correct 87 ms 15188 KB Output is correct
20 Correct 70 ms 13620 KB Output is correct
21 Correct 81 ms 15080 KB Output is correct
22 Correct 65 ms 13392 KB Output is correct
23 Correct 90 ms 14892 KB Output is correct
24 Correct 0 ms 344 KB Output is correct
25 Runtime error 1 ms 344 KB Execution killed with signal 11
26 Halted 0 ms 0 KB -