oj.uz

Submission #702565

# Submission time Handle Problem Language Result Execution time Memory
702565 2023-02-24T12:21:54 Z boris_mihov Catfish Farm (IOI22_fish) C++17
9 / 100
 1000 ms 60628 KB 
#include "fish.h"
#include <algorithm>
#include <iostream>
#include <cassert>
#include <numeric>
#include <vector>
 
typedef long long llong;
const int MAXN = 100000 + 10;
const int MAXM = 600000 + 10;
 
struct Position
{
    int y;
    int idx;
    llong in;
    llong left;
    llong right;
 
    Position(int _y, int _idx, llong _in, llong _left, llong _right)
    {
        y = _y;
        idx = _idx;
        left = _left;
        right = _right;
        in = _in;
    }
};
 
int cnt;
int n, m;
llong dp[MAXM][2];
std::vector <Position> pos[MAXN];
std::vector <Position> posUncleared[MAXN];
std::vector <std::pair <int,int>> fish[MAXN]; 
llong max_weights(int N, int M, std::vector <int> X, std::vector <int> Y, std::vector <int> W) 
{
    n = N; m = M;   
    for (int i = 0 ; i < m ; ++i)
    {
        fish[X[i] + 1].emplace_back(Y[i] + 1, W[i]);
    }
 
    for (int x = 1 ; x <= n ; ++x)
    {
        std::sort(fish[x].begin(), fish[x].end());
        for (const auto &[y, w] : fish[x])
        {
            if (x != 1)
            {
                posUncleared[x - 1].push_back({y, 0, 0LL, 0LL, 0LL});
            }
 
            if (x != n)
            {
                posUncleared[x + 1].push_back({y, 0, 0LL, 0LL, 0LL});
            }
        }
    }
 
    for (int x = 1 ; x <= n ; ++x)
    {
        std::sort(posUncleared[x].begin(), posUncleared[x].end(), [&](Position a, Position b)
        {
            return a.y < b.y;
        });
        
        for (Position p : posUncleared[x])
        {
            if (!pos[x].empty() && pos[x].back().y == p.y)
            {
                continue;
            }
 
            pos[x].push_back(p);
        }
 
        int ptrL = 0;
        int ptrR = 0;
        int ptrIN = 0;
        llong inSum = 0;
        llong leftSum = 0;
        llong rightSum = 0;
        for (Position &p : pos[x])
        {
            while (ptrL < fish[x - 1].size() && fish[x - 1][ptrL].first <= p.y)
            {
                leftSum += fish[x - 1][ptrL].second;
                ptrL++;
            }
 
            while (ptrR < fish[x + 1].size() && fish[x + 1][ptrR].first <= p.y)
            {
                rightSum += fish[x + 1][ptrR].second;
                ptrR++;
            }
 
            while (ptrIN < fish[x].size() && fish[x][ptrIN].first <= p.y)
            {
                inSum += fish[x][ptrIN].second;
                ptrIN++;
            }
 
            p.in = inSum;
            p.left = leftSum;
            p.right = rightSum;
        }
    }
    
    for (int x = 1 ; x <= n ; ++x)
    {
        for (Position &p : pos[x])
        {
            p.idx = ++cnt;
        }
    }

    llong max = 0;
    for (int x = n - 1 ; x >= 1 ; --x)
    {
        if (x + 3 <= n)
        {
            for (const Position &curr : pos[x + 3])
            {
                max = std::max(max, dp[curr.idx][0] + curr.left + curr.right);
            }
        }

        for (int type = 0 ; type < 2 ; ++type)
        {
            for (const Position &curr : pos[x])
            {
                dp[curr.idx][type] = max;
                for (const Position &next : pos[x + 1])
                {
                    if (next.y < curr.y)
                    {
                        dp[curr.idx][type] = std::max(dp[curr.idx][type], dp[next.idx][1] + next.right - next.in);
                    } else
                    {
                        dp[curr.idx][type] = std::max(dp[curr.idx][type], dp[next.idx][0] + next.left + next.right - curr.in - curr.right);
                    }
                }
 
                if (x + 2 <= n)
                {
                    for (const Position &next : pos[x + 2])
                    {
                        if (next.y < curr.y)
                        {
                            dp[curr.idx][type] = std::max(dp[curr.idx][type], dp[next.idx][0] + next.right - next.left);
                        } else
                        {
                            dp[curr.idx][type] = std::max(dp[curr.idx][type], dp[next.idx][0] + next.left + next.right - curr.right);
                        }
                    }
                }
            }
        }
    }

    for (int x = std::min(n, 3) ; x >= 1 ; --x)
    {
        for (const Position &curr : pos[x])
        {
            max = std::max(max, dp[curr.idx][0] + curr.left + curr.right);
        }
    }
 
    return max;
}

Compilation message

fish.cpp: In function 'llong max_weights(int, int, std::vector<int>, std::vector<int>, std::vector<int>)':
fish.cpp:86:25: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   86 |             while (ptrL < fish[x - 1].size() && fish[x - 1][ptrL].first <= p.y)
      |                    ~~~~~^~~~~~~~~~~~~~~~~~~~
fish.cpp:92:25: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   92 |             while (ptrR < fish[x + 1].size() && fish[x + 1][ptrR].first <= p.y)
      |                    ~~~~~^~~~~~~~~~~~~~~~~~~~
fish.cpp:98:26: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   98 |             while (ptrIN < fish[x].size() && fish[x][ptrIN].first <= p.y)
      |                    ~~~~~~^~~~~~~~~~~~~~~~

Subtask #1
0 / 3.0

# Verdict Execution time Memory Grader output
1 Correct 43 ms 18620 KB Output is correct
2 Correct 50 ms 19784 KB Output is correct
3 Correct 4 ms 7252 KB Output is correct
4 Correct 5 ms 7252 KB Output is correct
5 Execution timed out 1092 ms 60628 KB Time limit exceeded
6 Halted 0 ms 0 KB -

Subtask #2
0 / 6.0

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

Subtask #3
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 7252 KB Output is correct
2 Correct 6 ms 7308 KB Output is correct
3 Correct 36 ms 18112 KB Output is correct
4 Correct 25 ms 14676 KB Output is correct
5 Correct 73 ms 26820 KB Output is correct
6 Correct 65 ms 26864 KB Output is correct
7 Correct 73 ms 26872 KB Output is correct
8 Correct 75 ms 26824 KB Output is correct

Subtask #4
0 / 14.0

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

Subtask #5
0 / 21.0

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

Subtask #6
0 / 17.0

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

Subtask #7
0 / 14.0

# Verdict Execution time Memory Grader output
1 Correct 5 ms 7252 KB Output is correct
2 Correct 6 ms 7308 KB Output is correct
3 Correct 36 ms 18112 KB Output is correct
4 Correct 25 ms 14676 KB Output is correct
5 Correct 73 ms 26820 KB Output is correct
6 Correct 65 ms 26864 KB Output is correct
7 Correct 73 ms 26872 KB Output is correct
8 Correct 75 ms 26824 KB Output is correct
9 Correct 88 ms 31576 KB Output is correct
10 Incorrect 68 ms 23760 KB 1st lines differ - on the 1st token, expected: '36454348383152', found: '37838158552678'
11 Halted 0 ms 0 KB -

Subtask #8
0 / 16.0

# Verdict Execution time Memory Grader output
1 Correct 43 ms 18620 KB Output is correct
2 Correct 50 ms 19784 KB Output is correct
3 Correct 4 ms 7252 KB Output is correct
4 Correct 5 ms 7252 KB Output is correct
5 Execution timed out 1092 ms 60628 KB Time limit exceeded
6 Halted 0 ms 0 KB -