Submission #868110

#	Submission time	Handle	Problem	Language	Result	Execution time	Memory
868110	2023-10-30T12:44:45 Z	sleepntsheep	Segments (IZhO18_segments)	C++17	16 / 100	875 ms	9792 KB

segments

#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx2,tune=native")

#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#define N 200005
int V;

int n, t, na, nc, S, id = 1;
struct line { int l, r, w; } a[N], c[N], o[N];
int e[N], f[N], we[N], wf[N], pf[N], sz[N];

int compare_length(const void *a0, const void *b0)
{
    const struct line *a = (const struct line*)a0, *b = (const struct line*)b0;
    if (a->r - a->l != b->r - b->l) return ((a->r - a->l) - (b->r - b->l));
    if (a->l != b->l) return a->l - b->l;
    return a->w - b->w;
}

int compare_left_increasing_index(const void *a0, const void *b0)
{
    const int aa = *(const int*)a0, bb = *(const int*)b0;
    if (a[aa].l != a[bb].l) return a[aa].l - a[bb].l;
    if (a[aa].r != a[bb].r) return a[aa].r - a[bb].r;
    return a[aa].w - a[bb].w;
}

int compare_right_increasing_index(const void *a0, const void *b0)
{
    const int aa = *(const int*)a0, bb = *(const int*)b0;
    if (a[aa].r != a[bb].r) return a[aa].r - a[bb].r;
    if (a[aa].l != a[bb].l) return a[aa].l - a[bb].l;
    return a[aa].w - a[bb].w;
}

inline void rebuild()
{
    for (; nc;) a[na++] = c[--nc];
    qsort(a, na, sizeof *a, compare_length);
    memset(sz, 0, sizeof *sz * (na / V + 1));
    for (int i = 0; i < na; ++i) e[i] = f[i] = i, ++sz[i/V];
    pf[0] = a[0].w;
    for (int i = 1; i < na; ++i) pf[i] = pf[i-1] + a[i].w;
    for (int i = 0; i * V <= na; ++i)
    {
        qsort(e+i*V, sz[i], sizeof *e, compare_left_increasing_index);
        qsort(f+i*V, sz[i], sizeof *f, compare_right_increasing_index);

        we[i*V+sz[i]-1] = a[e[i*V+sz[i]-1]].w;
        for (int j = i*V+sz[i]-1; --j >= i*V;) we[j] = we[j+1] + a[e[j]].w;
        wf[i*V] = a[f[i*V]].w;
        for (int j = i*V+1; j < i*V+sz[i]; ++j) wf[j] = wf[j-1] + a[f[j]].w;
    }
}

int main(void)
{
    scanf("%d%d", &n, &t);
    V = sqrt(n * log2(n));

    for (int z = 0, lastans = 0, op, x, y, k, l, r; n--;)
    {
        scanf("%d%d", &op, &x);
        switch (op)
        {
            case 1:
                scanf("%d", &y);
                l = x ^ (t * lastans), r = y ^ (t * lastans);
                if (l>r) { int t=l;l=r;r=t;}
                o[id++] = c[nc++] = (struct line){l, r, 1};
                if (nc == V) rebuild();
                ++S;
                break;
            case 2:
                c[nc++] = (struct line){o[x].l, o[x].r, -1};
                if (nc == V) rebuild();
                --S;
                break;
            default:
                scanf("%d%d", &y, &k); z=0;
                l = x ^ (t * lastans), r = y ^ (t * lastans);
                if (l>r) { int t=l;l=r;r=t;}
                /* count in static */
                {
                    int Z = -1;
                    for (int L = 0, R = na-1; L <= R; )
                    {
                        int M = (L+R)/2;
                        if (a[M].r - a[M].l + 1 >= k) R = M - 1, Z = M;
                        else L = M + 1;
                    }
                    if (Z != -1)
                    {
                        z -= (Z>0) * pf[Z-1];
                        int zb = Z/V, sb = zb+1;
                        for (struct line *j = a + Z; j < a + sb * V; ++j) z -= (j->r < l + k - 1 || j->l > r - k + 1) * j->w;
                        for (int j = sb; j * V <= na; ++j)
                        {
                            /* r - j->l + 1 < k === j->l > r - k + 1 */
                            int cnt = 0;
                            for (int L = 0, R = sz[j]-1; L <= R;)
                            {
                                int M = (L+R)/2;
                                if (a[e[j*V+M]].l > r - k + 1) R = M - 1, cnt = we[j*V+M];
                                else L = M + 1;
                            }
                            z -= cnt;
                            cnt = 0;
                            /* j->r - l + 1 < k === j->l < k + l - 1 */
                            for (int L = 0, R = sz[j]-1; L <= R;)
                            {
                                int M = (L+R)/2;
                                if (a[f[j*V+M]].r < k + l - 1) L = M + 1, cnt = wf[j*V+M];
                                else R = M - 1;
                            }
                            z -= cnt;
                        }
                    }
                }

                /* count in buffer */
                for (struct line *j = c; j < c + nc; ++j) z -= (j->r < l + k - 1 || j->l > r - k + 1) * j->w;
                lastans = (z += S);
                printf("%d\n", z);
                break;
        }
    }
    return 0;
}

Compilation message

segments.cpp: In function 'int main()':
segments.cpp:62:10: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
   62 |     scanf("%d%d", &n, &t);
      |     ~~~~~^~~~~~~~~~~~~~~~
segments.cpp:67:14: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
   67 |         scanf("%d%d", &op, &x);
      |         ~~~~~^~~~~~~~~~~~~~~~~
segments.cpp:71:22: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
   71 |                 scanf("%d", &y);
      |                 ~~~~~^~~~~~~~~~
segments.cpp:84:22: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
   84 |                 scanf("%d%d", &y, &k); z=0;
      |                 ~~~~~^~~~~~~~~~~~~~~~

Subtask #1
0 / 7.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	1 ms	8540 KB	Output is correct
2	Correct	1 ms	8540 KB	Output is correct
3	Incorrect	6 ms	8536 KB	Output isn't correct
4	Halted	0 ms	0 KB	-

Subtask #2
0 / 15.0

#	Verdict	Execution time	Memory	Grader output
1	Incorrect	509 ms	9160 KB	Output isn't correct
2	Halted	0 ms	0 KB	-

Subtask #3
16.0 / 16.0

#	Verdict	Execution time	Memory	Grader output
1	Correct	482 ms	9440 KB	Output is correct
2	Correct	478 ms	9412 KB	Output is correct
3	Correct	480 ms	9400 KB	Output is correct
4	Correct	484 ms	9424 KB	Output is correct
5	Correct	733 ms	9468 KB	Output is correct
6	Correct	674 ms	9236 KB	Output is correct
7	Correct	709 ms	9316 KB	Output is correct
8	Correct	852 ms	9624 KB	Output is correct
9	Correct	875 ms	9636 KB	Output is correct
10	Correct	803 ms	9604 KB	Output is correct
11	Correct	519 ms	9568 KB	Output is correct
12	Correct	820 ms	9624 KB	Output is correct
13	Correct	751 ms	9792 KB	Output is correct
14	Correct	612 ms	9532 KB	Output is correct
15	Correct	590 ms	9520 KB	Output is correct
16	Correct	552 ms	9576 KB	Output is correct
17	Correct	595 ms	9248 KB	Output is correct
18	Correct	590 ms	9204 KB	Output is correct
19	Correct	589 ms	9144 KB	Output is correct
20	Correct	623 ms	9180 KB	Output is correct
21	Correct	535 ms	9628 KB	Output is correct
22	Correct	687 ms	9516 KB	Output is correct
23	Correct	755 ms	9508 KB	Output is correct
24	Correct	711 ms	9520 KB	Output is correct
25	Correct	482 ms	9444 KB	Output is correct
26	Correct	479 ms	9392 KB	Output is correct
27	Correct	477 ms	9432 KB	Output is correct
28	Correct	483 ms	9632 KB	Output is correct
29	Correct	765 ms	9624 KB	Output is correct
30	Correct	761 ms	9552 KB	Output is correct
31	Correct	866 ms	9620 KB	Output is correct
32	Correct	802 ms	9608 KB	Output is correct
33	Correct	756 ms	9512 KB	Output is correct
34	Correct	594 ms	9576 KB	Output is correct
35	Correct	701 ms	9508 KB	Output is correct
36	Correct	777 ms	9784 KB	Output is correct