oj.uz

Submission #601864

# Submission time Handle Problem Language Result Execution time Memory
601864 2022-07-22T11:17:27 Z MohamedAliSaidane Unscrambling a Messy Bug (IOI16_messy) C++14
100 / 100
 2 ms 500 KB 
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include "messy.h"
        using namespace __gnu_pbds;
        using namespace std;

        typedef tree<int,null_type,less<int>,rb_tree_tag,
        tree_order_statistics_node_update> indexed_set;

        typedef long long ll;
        typedef long double ld;

        //#define int ll

        typedef pair<int,int> pii;
        typedef pair<ll,ll> pll;
        typedef pair<ld,ld> pld;

        typedef vector<int> vi;
        typedef vector<ll> vll;
        typedef vector<pii> vpi;
        typedef vector<pll> vpl;

        #define pb push_back
        #define popb pop_back
        #define pp pop_back
        #define pf push_front
        #define popf pop_front
        #define all(x) (x).begin(),(x).end()
        #define ff first
        #define ss second



        int nx[4] = {0,0,1,-1}, ny[4] = {1,-1,0,0};
        ll gcd(ll a , ll b) {return b ? gcd(b , a % b) : a ;}
        ll lcm(ll a , ll b) {return (a * b) / gcd(a , b);}


        const ll MOD =   998244353;
         vi restore_permutation(int n, int w, int r);
        /*
        namespace helper {

            set<string> set_;
            bool compiled = false;
            int n;
            vector<int> p;
            int w;
            int r;

            int read_int() {
                int x;
                cin >> x;
                return x;
            }

        }

        using namespace helper;


        // A convenience function.
        int get_p(int i) {
            int ret = p[i];
            return ret;
        }

        int main() {
            n = read_int();
            w = read_int();
            r = read_int();
            p = vector<int>(n);
            for (int i = 0; i < n; i++) {
                p[i] = read_int();
            }
            vector<int> answer = restore_permutation(n, w, r);

            if (answer.size() != n) {
                printf("WA\n");
                return 0;
            }


            printf("%d", answer[0]);

            for (int i = 1; i < n; i++) {
                printf(" %d", answer[i]);
            }
            printf("\n");
            return 0;
        }

        void wa() {
            printf("WA\n");
            exit(0);
        }

        bool check(const string& x) {
            if ((int)x.length() != n) {
                return false;
            }
            for (int i = 0; i < n; i++) {
                if (x[i] != '0' && x[i] != '1') {
                    return false;
                }
            }
            return true;
        }

        void add_element(string x) {
            if (--w < 0 || compiled || !check(x)) {
                wa();
            }
            set_.insert(x);
        }

        bool check_element(string x) {
            if (--r < 0 || !compiled || !check(x)) {
                wa();
            }
            return set_.count(x);
        }

        void compile_set() {
            if (compiled) {
                wa();
            }
            compiled = true;
            set<string> compiledSet;
            string compiledElement = string(n, ' ');
            for (set<string>::iterator it = set_.begin(); it != set_.end(); it++) {
                string s = *it;
                for (int i = 0; i < n; i++) {
                    compiledElement[i] = s[get_p(i)];
                }
                compiledSet.insert(compiledElement);
            }
            set_ = compiledSet;
        }
        */
        int n ;
        vi perm;
        void divconq(int l, int r)
        {
            if(l == r)
                return ;
            string cur=  "";
            for(int i= 0  ; i < n ;i ++)
                cur += '1';
            for(int i= l ;i  <= r; i ++)
                cur[i] = '0';
            int m= (l + r)/2;
            for(int i  = l; i <= m; i++)
            {
                cur[i] = '1';
                add_element(cur);
                cur[i] = '0';
            }
            divconq(l, m);
            divconq(m + 1, r);
        }
        void det(int l, int r, vi pot)
        {
            if(l == r)
            {
                assert(pot.size() == 1);
                for(auto e: pot)
                {
                    perm[e] = l;
                    return ;
                }
            }
            int seen[n];
            memset(seen,0,sizeof(seen));
            for(auto e: pot)
                seen[e] = 1;
            string cur = "";
            for(int i = 0; i < n; i ++)
            {
                if(seen[i])
                    cur += '0';
                else
                    cur += '1';
            }
            vi lef, rig;
            for(auto e: pot)
            {
                cur[e] = '1';
                if(check_element(cur))
                    lef.pb(e);
                else
                    rig.pb(e);
                cur[e] = '0';
            }
            int m=  (l + r)/2;
            det(l, m, lef);
            det(m + 1, r, rig);
        }
        vi restore_permutation(int N, int w, int r)
        {
            n = N;
            perm.resize(n);
            divconq(0, N - 1);
            compile_set();
            vi emp;
            for(int i = 0; i < n; i++)
                emp.pb(i);
            det(0, N - 1, emp);
            return perm;
        }

Subtask #1
20.0 / 20.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 212 KB n = 8
2 Correct 0 ms 212 KB n = 8
3 Correct 0 ms 212 KB n = 8
4 Correct 0 ms 212 KB n = 8
5 Correct 1 ms 212 KB n = 8
6 Correct 0 ms 212 KB n = 8
7 Correct 0 ms 212 KB n = 8
8 Correct 0 ms 212 KB n = 8
9 Correct 0 ms 212 KB n = 8
10 Correct 0 ms 212 KB n = 8
11 Correct 0 ms 212 KB n = 8
12 Correct 0 ms 212 KB n = 8
13 Correct 0 ms 212 KB n = 8
14 Correct 0 ms 212 KB n = 8
15 Correct 1 ms 212 KB n = 8

Subtask #2
18.0 / 18.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB n = 32
2 Correct 1 ms 296 KB n = 32
3 Correct 1 ms 212 KB n = 32
4 Correct 1 ms 212 KB n = 32
5 Correct 1 ms 212 KB n = 32
6 Correct 1 ms 212 KB n = 32
7 Correct 0 ms 212 KB n = 32
8 Correct 1 ms 212 KB n = 32
9 Correct 1 ms 212 KB n = 32
10 Correct 1 ms 300 KB n = 32
11 Correct 1 ms 212 KB n = 32
12 Correct 1 ms 212 KB n = 32
13 Correct 1 ms 212 KB n = 32
14 Correct 1 ms 212 KB n = 32
15 Correct 0 ms 212 KB n = 32

Subtask #3
11.0 / 11.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 212 KB n = 32
2 Correct 0 ms 212 KB n = 32
3 Correct 1 ms 212 KB n = 32
4 Correct 1 ms 212 KB n = 32
5 Correct 1 ms 304 KB n = 32
6 Correct 0 ms 212 KB n = 32
7 Correct 1 ms 212 KB n = 32
8 Correct 1 ms 212 KB n = 32
9 Correct 1 ms 212 KB n = 32
10 Correct 1 ms 212 KB n = 32
11 Correct 1 ms 212 KB n = 32
12 Correct 1 ms 212 KB n = 32
13 Correct 1 ms 212 KB n = 32
14 Correct 1 ms 212 KB n = 32
15 Correct 0 ms 212 KB n = 32

Subtask #4
21.0 / 21.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 500 KB n = 128
2 Correct 2 ms 432 KB n = 128
3 Correct 2 ms 468 KB n = 128
4 Correct 2 ms 468 KB n = 128
5 Correct 2 ms 468 KB n = 128
6 Correct 2 ms 468 KB n = 128
7 Correct 2 ms 468 KB n = 128
8 Correct 2 ms 424 KB n = 128
9 Correct 1 ms 424 KB n = 128
10 Correct 2 ms 468 KB n = 128
11 Correct 2 ms 468 KB n = 128
12 Correct 2 ms 468 KB n = 128
13 Correct 2 ms 468 KB n = 128
14 Correct 2 ms 468 KB n = 128
15 Correct 2 ms 480 KB n = 128

Subtask #5
30.0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 2 ms 468 KB n = 128
2 Correct 2 ms 428 KB n = 128
3 Correct 2 ms 468 KB n = 128
4 Correct 2 ms 468 KB n = 128
5 Correct 2 ms 432 KB n = 128
6 Correct 2 ms 468 KB n = 128
7 Correct 2 ms 468 KB n = 128
8 Correct 2 ms 412 KB n = 128
9 Correct 2 ms 468 KB n = 128
10 Correct 1 ms 468 KB n = 128
11 Correct 1 ms 468 KB n = 128
12 Correct 2 ms 468 KB n = 128
13 Correct 1 ms 468 KB n = 128
14 Correct 1 ms 468 KB n = 128
15 Correct 2 ms 468 KB n = 128