Submission #681202

#	Time	Username	Problem	Language	Result	Execution time	Memory
681202		USER	XOR Sum (info1cup17_xorsum)	C++14	56 / 100	1684 ms	72588 KiB

xorsum

#include <bits/stdc++.h> 
using namespace std;
 
class input {
private:
    char* t;
    int sp;
    const int sz = 10000;
 
    char read()
    {
        if (sp == sz)
        {
            fread(t, 1, sz, stdin);
            sp = 0;
            return t[sp++];
        }
        else
            return t[sp++];
    }
public:
    input()
    {
        sp = sz;
        t = new char[sz]();
    }
 
    input& operator >> (int& n)
    {
        char c = read();
 
        while (c == ' ' || c == '\n')
            c = read();
 
        n = 0;
 
        int sng = 1;
 
        if (c == '-')
            sng = -1, c = read();
 
        while (c != '\0' && isdigit(c))
            n = n * 10 + (c - '0'), c = read();
 
        n *= sng;
 
        return *this;
    }
 
    input& operator >> (char& s)
    {
        char c = read();
 
        while (c != '\0' && c == '\n')
            c = read();
 
        s = c;
 
        return *this;
    }
 
    input& operator >> (long long& n)
    {
        char c = read();
 
        while (c == ' ' || c == '\n')
            c = read();
 
        n = 0;
 
        int sng = 1;
 
        if (c == '-')
            sng = -1, c = read();
 
        while (c != '\0' && isdigit(c))
            n = n * 10 + (c - '0'), c = read();
 
        n *= sng;
 
        return *this;
    }
 
    void getline(string& s)
    {
        char c = read();
        s = "";
 
        while (c != '\0' && c != '\n')
            s += c, c = read();
    }
 
    input& operator >> (string& s)
    {
        char c;
        c = read();
        s = "";
 
        while (c == '\n' || c == ' ')
            c = read();
 
        while (c != '\n' && c != '\0' && c != ' ')
            s += c, c = read();
 
        return *this;
    }
 
    input& operator >> (char* s)
    {
        char c;
        c = read();
        int i = 0;
 
        while (c == '\n' || c == ' ')
            c = read();
 
        while (c != '\n' && c != '\0' && c != ' ')
            s[i++] = c, c = read();
 
        return *this;
    }
};
class output {
private:
    char* t;
    int sp;
    const int sz = 10000;
 
    void write(char c)
    {
        if (sp == sz)
        {
            fwrite(t, 1, sz, stdout);
            sp = 0;
            t[sp++] = c;
        }
        else
            t[sp++] = c;
    }
 
public:
    output()
    {
        sp = 0;
        t = new char[sz]();
    }
 
    ~output()
    {
        fwrite(t, 1, sp, stdout);
    }
 
    output& operator << (int n)
    {
        if (n < 0)
        {
            write('-');
            n *= -1;
        }
        if (n <= 9)
            write(char(n + '0'));
        else
        {
            (*this) << (n / 10);
            write(char(n % 10 + '0'));
        }
 
        return *this;
    }
 
    output& operator << (char c)
    {
        write(c);
 
        return *this;
    }
 
    output& operator << (const char* s)
    {
        int i = 0;
 
        while (s[i] != '\0')
            write(s[i++]);
 
        return *this;
    }
 
    output& operator << (long long n)
    {
        if (n < 0)
        {
            write('-');
            n *= -1;
        }
        if (n < 10)
            write(char(n + '0'));
        else
        {
            (*this) << (n / 10);
            write(char(n % 10 + '0'));
        }
 
        return *this;
    }
 
    output& operator << (string s)
    {
        for (auto i : s)
            write(i);
 
        return *this;
    }
 
    void precizion(double x, int nr)
    {
        int p = int(floor(x));
 
        *this << p;
 
        if (nr == 0)
            return;
 
        write('.');
 
        for (int i = 1; i <= nr; i++)
        {
            x -= floor(x);
            x *= 10;
 
            write(int(x) + '0');
        }
    }
};
 
struct nod {
    int val, hight, nr, fr;
    nod* left, * right;
};
 
nod* root;
 
class Set {
private:
 
#define sub(p) (p == NULL ? 0 : p->nr)
#define hight(p) (p == NULL ? 0 : p->hight)
#define getBalanced(p) (p == NULL ? 0 : hight(p->left) - hight(p->right))
 
    inline nod* New(int val)
    {
        nod* p = new nod;
 
        p->val = val;
        p->left = p->right = NULL;
        p->nr = p->hight = 1;
        p->fr = 1;
 
        return p;
    }
 
    inline nod* to_right(nod* x)
    {
        nod* y = x->left;
        nod* z = y->right;
 
        y->right = x;
        x->left = z;
 
        x->hight = max(hight(x->left), hight(x->right)) + 1;
        y->hight = max(hight(y->left), hight(y->right)) + 1;
 
        x->nr = sub(x->left) + sub(x->right) + x->fr;
        y->nr = sub(y->left) + sub(y->right) + y->fr;
 
        return y;
    }
 
    inline nod* to_left(nod* x)
    {
        nod* y = x->right;
        nod* z = y->left;
 
        y->left = x;
        x->right = z;
 
        x->hight = max(hight(x->left), hight(x->right)) + 1;
        y->hight = max(hight(y->left), hight(y->right)) + 1;
 
        x->nr = sub(x->left) + sub(x->right) + x->fr;
        y->nr = sub(y->left) + sub(y->right) + y->fr;
 
        return y;
    }
 
    inline nod* add(nod* root, int val)
    {
        if (root == NULL)
            return New(val);
 
        if (root->val < val)
            root->right = add(root->right, val);
        else if (root->val > val)
            root->left = add(root->left, val);
        else
        {
            root->fr++;
            root->nr++;
            return root;
        }
 
        root->hight = max(hight(root->left), hight(root->right)) + 1;
        root->nr = sub(root->left) + sub(root->right) + root->fr;
 
        int b = getBalanced(root);
 
        if (b > 1)
        {
            if (val < root->left->val)
                return to_right(root);
            else
            {
                root->left = to_left(root->left);
                return to_right(root);
            }
        }
        else if (b < -1)
        {
            if (val > root->right->val)
                return to_left(root);
            else
            {
                root->right = to_right(root->right);
                return to_left(root);
            }
        }
 
        return root;
    }
 
    inline int greaterThanPrv(nod* p, int& val)
    {
        int total = 0;
 
        while (p != NULL)
        {
            if (p->val < val)
                p = p->right;
            else
            {
                total += sub(p->right) + p->fr;
                p = p->left;
            }
        }
 
        return total;
    }
 
    inline int lessThanPrv(nod* p, int& val)
    {
        int total = 0;
 
        while (p != NULL)
        {
            if (p->val > val)
                p = p->left;
            else
            {
                total += sub(p->left) + p->fr;
                p = p->right;
            }
        }
 
        return total;
    }
 
    inline int intervalPrv(nod* p, int& l, int& r)
    {
        while (p != NULL)
        {
            if (p->val < l)
                p = p->right;
            else if (p->val > r)
                p = p->left;
            else
                break;
        }
 
        if (p == NULL)
            return 0;
 
        return p->fr + lessThanPrv(p->right, r) + greaterThanPrv(p->left, l);
    }
 
public:
 
    Set()
    {
        root = NULL;
    }
 
    void clear()
    {
        root = NULL;
    }
 
    void insert(int val)
    {
        if (root == NULL)
        {
            root = new nod;
 
            root->nr = root->hight = 1;
            root->left = root->right = NULL;
            root->val = val;
            root->fr = 1;
            return;
        }
 
        root = add(root, val);
    }
};
 
input fin;
output fout;
//ofstream out("number.out");
 
// (((1 << k) <= nr && nr < (1 << (k + 1))) || (nr >= (1 << k) + (1 << (k + 1))))
 
int v[1000001], x[1000001], n, POW[32];
int* vp, * xp;
nod* p;
long long bit[30];
Set S;
 
int main()
{
    int maxi = 0;
 
    for (int i = 0; i <= 30; i++)
        POW[i] = (1 << i);
 
    fin >> n;
 
    for (int i = 1; i <= n; i++)
        fin >> v[i], maxi = max(maxi, v[i]);
 
    int stop = ceil(log2(maxi)) + 1, aux, l, r, total;
    nod* rod;
 
    for (int k = 0; k <= stop; k++)
    {
        vp = v;
        vp++;
 
        xp = x;
        xp++;
 
        for (int i = 1; i <= n; i++)
        {
            if (*vp & 1)
                *xp += POW[k];
            *vp >>= 1;
 
            S.insert(*xp);
 
            //bit[k] += S.interval(POW[k] - *xp, POW[k + 1] - *xp - 1); //+ S.greaterThan(POW[k] + POW[k + 1] - *xp);
            aux = POW[k] + POW[k + 1] - *xp;
 
            total = 0;
 
            p = root;
 
            while (p != NULL)
            {
                if (p->val < aux)
                    p = p->right;
                else
                {
                    total += sub(p->right) + p->fr;
                    p = p->left;
                }
            }
 
            l = POW[k] - *xp;
            r = POW[k + 1] - *xp - 1;
            p = root;
 
            while (p != NULL)
            {
                if (p->val < l)
                    p = p->right;
                else if (p->val > r)
                    p = p->left;
                else
                    break;
            }
 
            if (p != NULL)
            {
                rod = p;
                total += rod->fr;
 
                p = rod->left;
 
                while (p != NULL)
                {
                    if (p->val < l)
                        p = p->right;
                    else
                    {
                        total += sub(p->right) + p->fr;
                        p = p->left;
                    }
                }
 
                p = rod->right;
 
                while (p != NULL)
                {
                    if (p->val > r)
                        p = p->left;
                    else
                    {
                        total += sub(p->left) + p->fr;
                        p = p->right;
                    }
                }
            }
 
            bit[k] += total;
 
            vp++;
            xp++;
        }
 
        S.clear();
    }
 
    int res = 0;
 
    for (int k = 0; k <= 29; k++)
        if (bit[k] & 1)
            res += POW[k];
 
    fout << res;
 
    return 0;
}

Compilation message (stderr)

xorsum.cpp: In member function 'char input::read()':
xorsum.cpp:14:18: warning: ignoring return value of 'size_t fread(void*, size_t, size_t, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
   14 |             fread(t, 1, sz, stdin);
      |             ~~~~~^~~~~~~~~~~~~~~~~

• Subtask 1: 7 / 7
• Subtask 2: 11 / 11
• Subtask 3: 0 / 21
• Subtask 4: 38 / 38
• Subtask 5: 0 / 23