Submission #931246

#	Time	Username	Problem	Language	Result	Execution time	Memory
931246		LucaIlie	The Potion of Great Power (CEOI20_potion)	C++17	0 / 100	3035 ms	74564 KiB

potion

#include <bits/stdc++.h>

#pragma GCC optimize(" unroll-loops")
#pragma gcc optimize("Ofast")
#pragma GCC optimization("Ofast")
#pragma optimize(Ofast)

using namespace std;

struct change {
    int time, val;
};

const int MAX_N = 1e5;
const int MAX_M = 2e5;
int n, m, d;
int h[MAX_N], a[MAX_M], b[MAX_M];
unordered_map<int, int> pos[MAX_N];
vector<int> trust[MAX_N];
set<int> hx, hy;
vector<vector<vector<change>>> changes;
vector<change> emptyV;

void init( int N, int D, int H[] ) {
    n = N;
    d = D;
    for ( int i = 0; i < n; i++ )
        h[i] = H[i];
    changes.resize( n );
    emptyV.push_back( { -1, -1 } );
    for ( int i = 0; i < n; i++ ) {
        trust[i].push_back( i );
        changes[i].push_back( emptyV );
    }
}

void curseChanges( int M, int A[], int B[] ) {
    m = M;
    for ( int i = 0; i < M; i++ ) {
        a[i] = A[i];
        b[i] = B[i];
    }

    for ( int i = 0; i < m; i++ ) {
        if ( changes[a[i]].size() <= trust[a[i]].size() )
            changes[a[i]].push_back( emptyV );
        if ( changes[b[i]].size() <= trust[b[i]].size() )
            changes[b[i]].push_back( emptyV );

        if ( pos[a[i]][b[i]] == 0 ) {
            pos[a[i]][b[i]] = trust[a[i]].size();
            changes[a[i]][trust[a[i]].size()].push_back( { i, b[i] } );
            trust[a[i]].push_back( b[i] );

            pos[b[i]][a[i]] = trust[b[i]].size();
            changes[b[i]][trust[b[i]].size()].push_back( { i, a[i] } );
            trust[b[i]].push_back( a[i] );
        } else {
            int p, l;

            p = pos[a[i]][b[i]], l = trust[a[i]].size() - 1;
            swap( pos[a[i]][b[i]], pos[a[i]][trust[a[i]][l]] );
            swap( trust[a[i]][p], trust[a[i]][l] );
            changes[a[i]][p].push_back( { i, trust[a[i]][p] } );
            changes[a[i]][l].push_back( { i, -1 } );
            pos[a[i]][trust[a[i]][l]] = 0;
            trust[a[i]].pop_back();

            p = pos[b[i]][a[i]], l = trust[b[i]].size() - 1;
            swap( pos[b[i]][a[i]], pos[b[i]][trust[b[i]][l]] );
            swap( trust[b[i]][p], trust[b[i]][l] );
            changes[b[i]][p].push_back( { i, trust[b[i]][p] } );
            changes[b[i]][l].push_back( { i, -1 } );
            pos[b[i]][trust[b[i]][l]] = 0;
            trust[b[i]].pop_back();
        }
    }

    /*for ( int i = 0; i < n; i++ ) {
        printf( "%d: \n", i );
        for ( int j = 1; j <= d; j++ ) {
            for ( change ch: changes[i][j] )
                printf( "%d %d\n", ch.time, ch.val );
            printf( "\n" );
        }
        printf( "\n" );
    }*/
}

int question( int x, int y, int t ) {
    hx.clear();
    for ( int i = 1; i < changes[x].size(); i++ ) {
        int l = 0, r = changes[x][i].size();
        while ( r - l > 1 ) {
            int mid = (l + r) / 2;

            if ( changes[x][i][mid].time < t )
                l = mid;
            else
                r = mid;
        }
        //if ( changes[x][i][l].val != -1 )
            //hx.insert( h[changes[x][i][l].val] );
    }
    hy.clear();
    for ( int i = 1; i < changes[y].size(); i++ ) {
        int l = 0, r = changes[y][i].size();
        while ( r - l > 1 ) {
            int mid = (l + r) / 2;

            if ( changes[y][i][mid].time < t )
                l = mid;
            else
                r = mid;
        }
        //if ( changes[y][i][l].val != -1 )
            //hy.insert( h[changes[y][i][l].val] );
    }

    int minDist = 1e9;
    /*for ( int l: hx ) {
        if ( l == x )
            continue;

        auto p = hy.upper_bound( l );
        if ( p != hy.end() )
            minDist = min( minDist, *p - l );
        if ( p != hy.begin() ) {
            p--;
            minDist = min( minDist, l - *p );
        }
    }*/

    hy.clear();
    for ( int l: trust[y] ) {
        if ( l == y )
            continue;
        hy.insert( h[l] );
    }

    for ( int l: trust[x] ) {
        if ( l == x )
            continue;

        auto p = hy.upper_bound( h[l] );
        if ( p != hy.end() )
            minDist = min( minDist, *p - h[l] );
        if ( p != hy.begin() ) {
            p--;
            minDist = min( minDist, h[l] - *p );
        }
    }

    return minDist;
}

Compilation message (stderr)

potion.cpp:4: warning: ignoring '#pragma gcc optimize' [-Wunknown-pragmas]
    4 | #pragma gcc optimize("Ofast")
      | 
potion.cpp:5: warning: ignoring '#pragma GCC optimization' [-Wunknown-pragmas]
    5 | #pragma GCC optimization("Ofast")
      | 
potion.cpp:6: warning: ignoring '#pragma optimize ' [-Wunknown-pragmas]
    6 | #pragma optimize(Ofast)
      | 
potion.cpp:3:37: warning: bad option '-f unroll-loops' to pragma 'optimize' [-Wpragmas]
    3 | #pragma GCC optimize(" unroll-loops")
      |                                     ^
potion.cpp:24:34: warning: bad option '-f unroll-loops' to attribute 'optimize' [-Wattributes]
   24 | void init( int N, int D, int H[] ) {
      |                                  ^
potion.cpp:37:44: warning: bad option '-f unroll-loops' to attribute 'optimize' [-Wattributes]
   37 | void curseChanges( int M, int A[], int B[] ) {
      |                                            ^
potion.cpp:90:35: warning: bad option '-f unroll-loops' to attribute 'optimize' [-Wattributes]
   90 | int question( int x, int y, int t ) {
      |                                   ^
potion.cpp: In function 'int question(int, int, int)':
potion.cpp:92:24: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<change> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   92 |     for ( int i = 1; i < changes[x].size(); i++ ) {
      |                      ~~^~~~~~~~~~~~~~~~~~~
potion.cpp:106:24: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::vector<change> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  106 |     for ( int i = 1; i < changes[y].size(); i++ ) {
      |                      ~~^~~~~~~~~~~~~~~~~~~

• Subtask 1: 0 / 0
• Subtask 2: 0 / 17
• Subtask 3: 0 / 14
• Subtask 4: 0 / 18
• Subtask 5: 0 / 21
• Subtask 6: 0 / 30