oj.uz

Submission #287317

# Submission time Handle Problem Language Result Execution time Memory
287317 2020-08-31T15:23:07 Z stoyan_malinin Last supper (IOI12_supper) C++14
43 / 100
 457 ms 25896 KB 
#include "advisor.h"

#include <set>
#include <map>
#include <queue>
#include <vector>
#include <iostream>

using namespace std;

namespace Advisor
{
    const int MAXN = 1e5 + 5;
    int maxLog;

    int nxtSame[MAXN], firstSeen[MAXN];
    vector <int> numSeq[MAXN];

    void init(int n, int *a, int k)
    {
        for(int i = 0;i<k;i++)
        {
            for(int bit = 0;bit<=maxLog;bit++)
                numSeq[i].push_back(((i>>bit)&1));
        }

        map <int, int> last;
        for(int i = 0;i<n;i++)
        {
            last[i] = n;
            firstSeen[i] = n;
        }
        for(int i = n-1;i>=0;i--)
        {
            nxtSame[i] = last[ a[i] ];
            last[ a[i] ] = i;

            firstSeen[ a[i] ] = i;
        }
    }

    int calcLog(int x)
    {
        int ans = 0;
        while(x!=1) x /= 2, ans++;

        return ans;
    }

    template <class T>
    T getLast(set <T> &s)
    {
        auto it = s.end();

        it--;
        return *it;
    }

};

void ComputeAdvice(int *C, int N, int K, int M)
{
    using namespace Advisor;
    maxLog = calcLog(K);
    init(N, C, K);

    set <pair <int, int>> s;
    vector <int> colorPos(N), scaffold(K);

    for(int i = 0;i<N;i++)
    {
        colorPos[i] = -1;
    }
    for(int i = 0;i<K;i++)
    {
        scaffold[i] = i;
        colorPos[i] = i;
        s.insert({firstSeen[i], i});
    }

    for(int i = 0;i<N;i++)
    {
        //cout << " --- " << i << " --- " << '\n';

        if(colorPos[ C[i] ]!=-1)
        {
            s.erase({i, colorPos[ C[i] ]});
            s.insert({nxtSame[i], colorPos[ C[i] ]});

            continue;
        }

        //for(pair <int, int> item: s) cout << item.first << " " << item.second << " || ";
        //cout << '\n';

        pair <int, int> best = getLast(s);
        s.erase(best);

        //cout << best.first << " " << best.second << " -> " << scaffold[ best.second ] << '\n';

        colorPos[ scaffold[best.second] ] = -1;
        scaffold[best.second] = C[i];
        colorPos[ C[i] ] = best.second;

        for(int bit: numSeq[best.second]) WriteAdvice(bit);
        s.insert({nxtSame[i], best.second});
    }
}

#include "assistant.h"

#include <set>
#include <queue>
#include <vector>
#include <iostream>

using namespace std;

namespace Assitant
{
    const int MAXN = 1e5 + 5;
    int maxLog;

    int calcLog(int x)
    {
        int ans = 0;
        while(x!=1) x /= 2, ans++;

        return ans;
    }

    struct Reader
    {
        queue <int> q;

        Reader(){}
        Reader(int n, unsigned char *a)
        {
            for(int i = 0;i<n;i++)
                this->q.push(int(a[i]));
        }

        int readInt(int log2)
        {
            int x = 0;
            for(int bit = 0;bit<=log2;bit++)
            {
                int d = q.front();
                q.pop();

                x += (d<<bit);
            }

            return x;
        }
    };
};

void Assist(unsigned char *A, int N, int K, int R)
{
    using namespace Assitant;
    maxLog = calcLog(K);

    Reader yoanko(R, A);

    set <int> active;
    vector <int> scaffold(K);

    for(int i = 0;i<K;i++)
    {
        active.insert(i);
        scaffold[i] = i;
    }

    for(int iter = 0;iter<N;iter++)
    {
        int col = GetRequest();
        if(active.count(col)==true) continue;

        int pos = yoanko.readInt(maxLog);
        PutBack(scaffold[pos]);

        active.erase(scaffold[pos]);
        scaffold[pos] = col;
        active.insert(scaffold[pos]);
    }
}

Subtask #1
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 5376 KB Output is correct
2 Correct 3 ms 5376 KB Output is correct
3 Correct 4 ms 5632 KB Output is correct
4 Correct 7 ms 5888 KB Output is correct
5 Correct 8 ms 6144 KB Output is correct
6 Correct 17 ms 6144 KB Output is correct
7 Correct 10 ms 6400 KB Output is correct
8 Correct 18 ms 6400 KB Output is correct
9 Correct 17 ms 6400 KB Output is correct
10 Correct 15 ms 6400 KB Output is correct
11 Correct 15 ms 6400 KB Output is correct

Subtask #2
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 30 ms 7424 KB Output is correct
2 Correct 148 ms 13040 KB Output is correct
3 Correct 434 ms 25896 KB Output is correct
4 Correct 277 ms 19440 KB Output is correct
5 Correct 383 ms 19952 KB Output is correct
6 Correct 386 ms 20976 KB Output is correct
7 Correct 380 ms 22720 KB Output is correct
8 Correct 374 ms 21984 KB Output is correct
9 Correct 216 ms 18672 KB Output is correct
10 Correct 361 ms 24816 KB Output is correct

Subtask #3
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 297 ms 19784 KB Output is correct
2 Correct 376 ms 23280 KB Output is correct
3 Correct 369 ms 23536 KB Output is correct
4 Correct 348 ms 23280 KB Output is correct
5 Correct 306 ms 22256 KB Output is correct
6 Correct 367 ms 23544 KB Output is correct
7 Correct 358 ms 23536 KB Output is correct
8 Correct 457 ms 24496 KB Output is correct
9 Correct 275 ms 22768 KB Output is correct
10 Correct 368 ms 23536 KB Output is correct

Subtask #4
0 / 35.0

# Verdict Execution time Memory Grader output
1 Incorrect 5 ms 6144 KB Error - advice is too long
2 Halted 0 ms 0 KB -

Subtask #5
17.0 / 39.0

# Verdict Execution time Memory Grader output
1 Correct 379 ms 22768 KB Output is partially correct - 772365 bits used
2 Correct 370 ms 23024 KB Output is partially correct - 742095 bits used
3 Correct 370 ms 23536 KB Output is partially correct - 712470 bits used
4 Correct 373 ms 23536 KB Output is partially correct - 712005 bits used
5 Correct 367 ms 23536 KB Output is partially correct - 710610 bits used
6 Correct 376 ms 23536 KB Output is partially correct - 712155 bits used
7 Correct 369 ms 23536 KB Output is partially correct - 711090 bits used
8 Correct 362 ms 23552 KB Output is partially correct - 713340 bits used
9 Correct 361 ms 23536 KB Output is partially correct - 712830 bits used
10 Correct 442 ms 24304 KB Output is partially correct - 1117620 bits used