Submission #982301

#	Time	Username	Problem	Language	Result	Execution time	Memory
982301		davitmarg	Sequence (APIO23_sequence)	C++17	63 / 100	2031 ms	65044 KiB

sequence

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <cstring>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <bitset>
#include <stack>
#include <cassert>
#include <iterator>
#include <random>
#include <chrono>
#include <fstream>
#define fastIO                   \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0);
#define mod 1000000007ll
#define LL long long
#define LD long double
#define MP make_pair
#define PB push_back
#define all(v) v.begin(), v.end()
using namespace std;

const int N = 500005;

int n, a[N], ans;
vector<int> pos[N];
pair<int, int> t[N * 4];
pair<int, int> t2[N * 4];
int d[N * 4];
int d2[N * 4];

pair<int, int> merge(pair<int, int> a, pair<int, int> b)
{
    return MP(min(a.first, b.first), max(a.second, b.second));
}

void push(int v, int l, int r)
{
    if (d[v] == 0)
        return;
    if (l != r)
    {
        d[v * 2] += d[v];
        d[v * 2 + 1] += d[v];
    }
    t[v] = MP(t[v].first + d[v], t[v].second + d[v]);
    d[v] = 0;
}

void add(int v, int l, int r, int i, int j, int val)
{
    push(v, l, r);
    if (i > j)
        return;
    if (i == l && j == r)
    {
        d[v] += val;
        push(v, l, r);
        return;
    }

    int m = (l + r) / 2;
    add(v * 2, l, m, i, min(m, j), val);
    add(v * 2 + 1, m + 1, r, max(m + 1, i), j, val);
    t[v] = merge(t[v * 2], t[v * 2 + 1]);
}

pair<int, int> get(int v, int l, int r, int i, int j)
{
    push(v, l, r);
    if (i > j)
        return MP(mod, -mod);
    if (i == l && j == r)
        return t[v];

    int m = (l + r) / 2;
    return merge(
        get(v * 2, l, m, i, min(m, j)),
        get(v * 2 + 1, m + 1, r, max(m + 1, i), j)
    );
}

void push2(int v, int l, int r)
{
    if (d2[v] == 0)
        return;
    if (l != r)
    {
        d2[v * 2] += d2[v];
        d2[v * 2 + 1] += d2[v];
    }
    t2[v] = MP(t2[v].first + d2[v], t2[v].second + d2[v]);
    d2[v] = 0;
}

void add2(int v, int l, int r, int i, int j, int val)
{
    push2(v, l, r);
    if (i > j)
        return;
    if (i == l && j == r)
    {
        d2[v] += val;
        push2(v, l, r);
        return;
    }

    int m = (l + r) / 2;
    add2(v * 2, l, m, i, min(m, j), val);
    add2(v * 2 + 1, m + 1, r, max(m + 1, i), j, val);
    t2[v] = merge(t2[v * 2], t2[v * 2 + 1]);
}

pair<int, int> get2(int v, int l, int r, int i, int j)
{
    push2(v, l, r);
    if (i > j)
        return MP(mod, -mod);
    if (i == l && j == r)
        return t2[v];

    int m = (l + r) / 2;
    return merge(
        get2(v * 2, l, m, i, min(m, j)),
        get2(v * 2 + 1, m + 1, r, max(m + 1, i), j)
    );
}




int sequence(int nn, vector<int> aa)
{
    n = nn;
    for (int i = 1; i <= n; i++)
        a[i] = aa[i - 1];


    for (int i = 1; i <= n; i++)
        pos[a[i]].push_back(i);

    for (int i = 1; i <= n; i++)
    {
        add(1, 0, n, i, n, 1);
        add2(1, 0, n, i, n, 1);
    }


    for (int x = 1; x <= n; x++)
    {

        for (int p = 0; p < pos[x].size(); p++)
        {
            int i = pos[x][p];
            add2(1, 0, n, i, n, -2);
        }

        for (int p = 0; p < pos[x].size(); p++)
        {
            int i = pos[x][p];

            int l = 0;
            int r = p;
            
            while (l <= r)
            {
                int m = (l + r) / 2;

                int j = pos[x][m];
                int len = p - m + 1;

                pair<int, int> dr = get(1, 0, n, i, n);
                dr.first -= len;
                dr.second -= len;
                pair<int, int> dl = get(1, 0, n, 0, j - 1);
                pair<int, int> d = MP(dr.first - dl.second, dr.second - dl.first);


                pair<int, int> dr2 = get2(1, 0, n, i, n);
                dr2.first += len;
                dr2.second += len;
                pair<int, int> dl2 = get2(1, 0, n, 0, j - 1);
                pair<int, int> d2 = MP(dr2.first - dl2.second, dr2.second - dl2.first);

                if ((d.second < 0 && len >= -d.second) || (d.first > 0 && len >= d.first) || (d.first <= 0 && d.second >= 0) || (d2.second < 0 && len >= -d2.second) || (d2.first > 0 && len >= d2.first) || (d2.first <= 0 && d2.second >= 0))
                {
                    ans = max(ans, len);
                    r = m - 1;
                }
                else
                    l = m + 1;
            }

        }

        for (int p = 0; p < pos[x].size(); p++)
        {
            int i = pos[x][p];
            add(1, 0, n, i, n, -2);
        }
    }


    return ans;
}

#ifdef death



void solve()
{
    int nn;
    vector<int> aa;
    cin >> nn;
    for (int i = 0; i < nn; i++)
    {
        int x;
        cin >> x;
        aa.push_back(x);
    }

    cout << sequence(nn, aa) << endl;
}

int main()
{
    fastIO;
    int T = 1;
    //cin >> T;
    while (T--)
        solve();
    return 0;
}
#endif // death

/*

7
1 2 3 1 2 1 3

9
1 1 2 3 4 3 2 1 1

14
2 6 2 5 3 4 2 1 4 3 5 6 3 2

*/

Compilation message (stderr)

sequence.cpp: In function 'int sequence(int, std::vector<int>)':
sequence.cpp:161:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  161 |         for (int p = 0; p < pos[x].size(); p++)
      |                         ~~^~~~~~~~~~~~~~~
sequence.cpp:167:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  167 |         for (int p = 0; p < pos[x].size(); p++)
      |                         ~~^~~~~~~~~~~~~~~
sequence.cpp:205:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  205 |         for (int p = 0; p < pos[x].size(); p++)
      |                         ~~^~~~~~~~~~~~~~~

• Subtask 1: 11 / 11
• Subtask 2: 17 / 17
• Subtask 3: 0 / 7
• Subtask 4: 0 / 12
• Subtask 5: 13 / 13
• Subtask 6: 22 / 22
• Subtask 7: 0 / 18