Submission #705236

#	Time	Username	Problem	Language	Result	Execution time	Memory
705236		danikoynov	Catfish Farm (IOI22_fish)	C++17	100 / 100	712 ms	124056 KiB

fish

#include "fish.h"

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int maxn = 1e5 + 10, smalln = 3010;

vector < pair < int, int > > col[maxn];
vector < int > state[maxn];
 unordered_set < int >  state_set[maxn];
vector < vector < ll > > dp[maxn];

vector < ll > pref[maxn];

ll get_sum(int j, int left, int right)
{
    if (left > right)
        return 0;

    int lf = 0, rf = (int)(col[j].size()) - 1;
    while(lf <= rf)
    {
        int mf = (lf + rf) / 2;
        if (col[j][mf].first >= left)
            rf = mf - 1;
        else
            lf = mf + 1;
    }

    int lb = rf;
    lf = 0;
    rf = (int)(col[j].size()) - 1;
    while(lf <= rf)
    {
        int mf = (lf + rf) / 2;
        ///cout << col[j][mf].second << endl;
        if (col[j][mf].first <= right)
            lf = mf + 1;
        else
            rf = mf - 1;
    }
    int rb = rf;
   /// cout << lb << " " << rb << " " << j << " " << left << " " << right << endl;
    if (lb >= rb || rb < 0)
        return 0;

    ll sum = pref[j][rb];
    if (lb >= 0)
        sum = sum - pref[j][lb];
       /// cout << sum << endl;
    return sum;
}

long long max_weights(int N, int M, std::vector<int> X, std::vector<int> Y,
                      std::vector<int> W)
{
    bool all_even = true, small_x = true;
    for (int i = 0; i < M; i ++)
    {
        if (X[i] % 2 != 0)
            all_even = false;
        if (X[i] > 1)
            small_x = false;
    }

    for (int i = 0; i < M; i ++)
    {
        col[X[i]].push_back({Y[i], W[i]});
    }

    for (int i = 0; i < N; i ++)
        sort(col[i].begin(), col[i].end());

    for (int i = 0; i < M; i ++)
    {
        if (X[i] != 0)
            state_set[X[i] - 1].insert(Y[i] + 1);
        if (X[i] != N - 1)
        state_set[X[i] + 1].insert(Y[i] + 1);
    }

    for (int i = 0; i < N; i ++)
    {
        state_set[i].insert(0);
        state_set[i].insert(N);
    }
    for (int i = 0; i < N; i ++)
    {
        for (auto it : state_set[i])
            state[i].push_back(it);
        sort(state[i].begin(), state[i].end());
    }

    if (all_even)
    {
        ll sum = 0;
        for (int i = 0; i < M; i ++)
            sum = sum + W[i];
        return sum;

    }
    else if (small_x)
    {

        ll zero = 0, one = 0;
        for (int i = 0; i < M; i ++)
        {
            if (X[i] == 0)
                zero += W[i];
            else
                one += W[i];
        }
        if (N == 2)
            return max(zero, one);

        int to = 0;
        ll cur = 0, ans = 0;
        for (int i = 0; i < col[0].size(); i ++)
        {
            if (cur + one > ans)
                ans = cur + one;
            cur += col[0][i].second;
            while(to < col[1].size() && col[1][to].first <= col[0][i].first)
            {
                one -= col[1][to].second;
                to ++;
            }
        }
        if (cur + one > ans)
            ans = cur + one;
        return ans;

    }



    /**for (int i = 0; i < N; i ++, cout << endl)
        for (int j = 0; j < N; j ++)
        cout << val[i][j] << " ";*/


    for (int i = 0; i < N; i ++)
    {
        pref[i].resize(col[i].size());
        if (col[i].size() == 0)
            continue;
        pref[i][0] = col[i][0].second;
        ///cout << col[i][0].second << endl;
        for (int j = 1; j < col[i].size(); j ++)
        {
            pref[i][j] = pref[i][j - 1] + col[i][j].second;
        }
    }

    for (int i = 0; i < N; i ++)
    {
        dp[i].resize(state[i].size());
        for (int j = 0; j < state[i].size(); j ++)
        {
            dp[i][j].resize(2);
        }
    }

    for (int j = 0; j < state[1].size(); j ++)
        dp[1][j][0] = dp[1][j][1] = 0;
    for (int i = 1; i < N; i ++)
    {

        ll so_far = 0, to = 0;
        for (int j = 0; j < state[i].size(); j ++)
        {
            if (j > 0)
                dp[i][j][1] = dp[i][j - 1][1] + get_sum(i - 1, state[i][j - 1], state[i][j] - 1);
            while(to < state[i - 1].size() && state[i - 1][to] <= state[i][j])
            {
                ///cout << i << " " << j << " :: " << state[i - 1][to] << " " << state[i][j] << endl;
                so_far = max(so_far, dp[i - 1][to][1] + get_sum(i - 1, state[i - 1][to], state[i][j] - 1));
                to ++;
            }
            dp[i][j][1] = max(dp[i][j][1], so_far);
        }

        so_far = 0;
        to = (int)(state[i - 1].size()) - 1;
        for (int j = (int)(state[i].size()) - 1; j >= 0; j --)
        {
            if (j + 1 < state[i].size())
                dp[i][j][0] = dp[i][j + 1][0] + get_sum(i, state[i][j], state[i][j + 1] - 1);
            while(to >= 0 && state[i - 1][to] >= state[i][j])
            {
                ///cout << i << " " << j << " ::: " << to << endl;
                so_far = max(so_far, max(dp[i - 1][to][0], dp[i - 1][to][1]) + get_sum(i, state[i][j], state[i - 1][to] - 1));
                to --;
            }
            dp[i][j][0] = max(dp[i][j][0], so_far);
        }


        if (i > 1)
        {

            so_far = 0;
            to = 0;
            for (int j = 0; j < state[i].size(); j ++)
            {
                while(to < state[i - 2].size() && state[i - 2][to] <= state[i][j])
                {
                    so_far = max(so_far, max(dp[i - 2][to][0], dp[i - 2][to][1]));
                    to ++;
                }
                dp[i][j][1] = max(so_far + get_sum(i - 1, 0, state[i][j] - 1), dp[i][j][1]);
            }
            so_far = 0;
            to = (int)(state[i - 2].size()) - 1;
            for (int j = (int)(state[i].size()) - 1; j >= 0; j --)
            {
                while(to >= 0 && state[i - 2][to] >= state[i][j])
                {
                    so_far = max(so_far, max(dp[i - 2][to][0], dp[i - 2][to][1]) + get_sum(i - 1, 0, state[i - 2][to] - 1));
                    to --;
                }
                dp[i][j][1] = max(so_far, dp[i][j][1]);
            }
        }
    }

    /**cout << "-----------" << endl;
    for (int i = 0; i < N; i ++, cout << endl)
        for (int j = 0; j < state[i].size(); j ++)
        cout << dp[i][j][0] << " ";
    cout << "-----------" << endl;
    for (int i = 0; i < N; i ++, cout << endl)
        for (int j = 0; j < state[i].size(); j ++)
        cout << dp[i][j][1] << " ";*/
    ll ans = 0;
    for (int j = 0; j < state[N - 1].size(); j ++)
        for (int t = 0; t < 2; t ++)
            ans = max(ans, dp[N - 1][j][t]);


    return ans;

}

Compilation message (stderr)

fish.cpp: In function 'long long int max_weights(int, int, std::vector<int>, std::vector<int>, std::vector<int>)':
fish.cpp:119:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  119 |         for (int i = 0; i < col[0].size(); i ++)
      |                         ~~^~~~~~~~~~~~~~~
fish.cpp:124:22: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  124 |             while(to < col[1].size() && col[1][to].first <= col[0][i].first)
      |                   ~~~^~~~~~~~~~~~~~~
fish.cpp:150:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  150 |         for (int j = 1; j < col[i].size(); j ++)
      |                         ~~^~~~~~~~~~~~~~~
fish.cpp:159:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  159 |         for (int j = 0; j < state[i].size(); j ++)
      |                         ~~^~~~~~~~~~~~~~~~~
fish.cpp:165:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  165 |     for (int j = 0; j < state[1].size(); j ++)
      |                     ~~^~~~~~~~~~~~~~~~~
fish.cpp:171:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  171 |         for (int j = 0; j < state[i].size(); j ++)
      |                         ~~^~~~~~~~~~~~~~~~~
fish.cpp:175:22: warning: comparison of integer expressions of different signedness: 'll' {aka 'long long int'} and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  175 |             while(to < state[i - 1].size() && state[i - 1][to] <= state[i][j])
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~
fish.cpp:188:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  188 |             if (j + 1 < state[i].size())
      |                 ~~~~~~^~~~~~~~~~~~~~~~~
fish.cpp:205:31: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  205 |             for (int j = 0; j < state[i].size(); j ++)
      |                             ~~^~~~~~~~~~~~~~~~~
fish.cpp:207:26: warning: comparison of integer expressions of different signedness: 'll' {aka 'long long int'} and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  207 |                 while(to < state[i - 2].size() && state[i - 2][to] <= state[i][j])
      |                       ~~~^~~~~~~~~~~~~~~~~~~~~
fish.cpp:237:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  237 |     for (int j = 0; j < state[N - 1].size(); j ++)
      |                     ~~^~~~~~~~~~~~~~~~~~~~~

• Subtask 1: 3 / 3
• Subtask 2: 6 / 6
• Subtask 3: 9 / 9
• Subtask 4: 14 / 14
• Subtask 5: 21 / 21
• Subtask 6: 17 / 17
• Subtask 7: 14 / 14
• Subtask 8: 16 / 16