제출 #485333

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
485333		blue	코끼리 (Dancing Elephants) (IOI11_elephants)	C++17	26 / 100	13 ms	1228 KiB

elephants

#include "elephants.h"
#include <vector>
#include <algorithm>
using namespace std;

const int maxN = 150'000;
// const int rt = 1000; //change value and check

const int block_count = 371;
const int block_size = 404;
const int recompute_freq = 100;

//block_size * block_count >= maxN


using vi = vector<int>;

int N;
int L;
int* X;
int* I;

void init(int N_, int L_, int X_[])
{
    N = N_;
    L = L_;
    X = new int[N];
    for(int i = 0; i < N; i++) X[i] = X_[i];

    I = new int[N];
    for(int i = 0; i < N; i++) I[i] = i;
}

int sz[block_count];
int blocklist[block_count][block_size + recompute_freq];
int block[5 + maxN];

int camera_count[5 + maxN];
int camera_reach[5 + maxN];

void compute_block(int b)
{
    sort(blocklist[b], blocklist[b] + sz[b], [] (int u, int v)
    {
        return X[u] < X[v];
    });

    int r = sz[b] - 1;
    for(int l = sz[b] - 1; l >= 0; l--)
    {
        while(X[blocklist[b][r]] - X[blocklist[b][l]] > L)
            r--;

        if(r == sz[b] - 1)
        {
            camera_count[blocklist[b][l]] = 1;
            camera_reach[blocklist[b][l]] = X[blocklist[b][l]] + L;
        }
        else
        {
            camera_count[blocklist[b][l]] = 1 + camera_count[blocklist[b][r+1]];
            camera_reach[blocklist[b][l]] = camera_reach[blocklist[b][r+1]];
        }
    }
}

void rebuild()
{
    sort(I, I+N, [] (int p, int q)
    {
        return X[p] < X[q];
    });

    for(int q = 0; q < block_count; q++)
        sz[q] = 0;

    for(int x = 0; x < N; x++)
    {
        int i = I[x];
        block[i] = x/block_size;
        blocklist[x/block_size][x%block_size] = i;
        sz[x/block_size]++;
    }



    for(int b = 0; b < block_count; b++)
        compute_block(b);
}




void erase_elephant(int oldblock, int i)
{
    for(int f = 0; f+1 < sz[oldblock]; f++)
    {
        if(blocklist[oldblock][f] == i)
            swap(blocklist[oldblock][f], blocklist[oldblock][f+1]);
    }

    sz[oldblock]--;
    compute_block(oldblock);
}

void insert_elephant(int newblock, int i)
{
    block[i] = newblock;
    sz[newblock]++;
    blocklist[newblock][sz[newblock]-1] = i;
    compute_block(newblock);
}


void change_X(int i, int y)
{
    int oldblock = block[i];

    int newblock = -1;
    int newblock_score = 2'000'000'001;
    for(int b = 0; b < block_count; b++)
    {
        if(!sz[b]) continue;

        int curr_score = abs(X[blocklist[b][0]] - y) + abs(X[blocklist[b][sz[b] - 1]] - y);
        if(curr_score < newblock_score)
        {
            newblock = b;
            newblock_score = curr_score;
        }
    }

    int oldX = X[i];

    X[i] = y;

    erase_elephant(oldblock, i);
    insert_elephant(newblock, i);
}

int answer()
{
    int res = 0;
    int b = 0;
    while(sz[b] == 0) b++;

    int st = blocklist[b][0];
    while(1)
    {
        int rc = camera_reach[st];
        res += camera_count[st];

        bool nonext = 0;

        while(1)
        {
            if(b >= block_count)
            {
                nonext = 1;
                break;
            }

            if(sz[b] == 0)
            {
                b++;
                continue;
            }

            if(X[blocklist[b][sz[b] - 1]] <= rc)
            {
                b++;
                continue;
            }

            break;
        }

        if(nonext) return res;

        int lo = 0;
        int hi = sz[b] - 1;
        while(lo != hi)
        {
            int mid = (lo+hi)/2;
            if(X[blocklist[b][mid]] <= rc) lo = mid+1;
            else hi = mid;
        }

        st = X[blocklist[b][lo]];
    }


    return -1;
}

int u_ct = -1;
int update(int i, int y)
{
    u_ct++;
    if(u_ct % recompute_freq == 0)
    {
        X[i] = y;
        rebuild();
    }
    else
    {
        change_X(i, y);
    }

    return answer();
}

컴파일 시 표준 에러 (stderr) 메시지

elephants.cpp: In function 'void change_X(int, int)':
elephants.cpp:133:9: warning: unused variable 'oldX' [-Wunused-variable]
  133 |     int oldX = X[i];
      |         ^~~~

• Subtask 1: 10 / 10
• Subtask 2: 16 / 16
• Subtask 3: 0 / 24
• Subtask 4: 0 / 47
• Subtask 5: 0 / 3