oj.uz

Submission #874419

# Submission time Handle Problem Language Result Execution time Memory
874419 2023-11-17T00:24:49 Z sleepntsheep Growing Trees (BOI11_grow) C++17
100 / 100
 146 ms 3624 KB 
#include <stdio.h>
#include <algorithm>

#define INLINE inline __attribute__((always_inline))
#define assert_(x) if (!(x)) __builtin_trap()

#define N 100001

#include <random>
#include <chrono>

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
unsigned seed = 0xcb1898af;

INLINE unsigned rand_(void)
{
    return (seed = (seed * 3)) >> 1;
}

int A[N], B[N], S[N], L[N], R[N], D[N], AT;

INLINE int treap(int x)
{
    A[++AT] = x; B[AT] = rng(); S[AT] = 1;
    return AT;
}

INLINE void pull(int v)
{
    S[v] = 1 + S[L[v]] + S[R[v]];
}

INLINE void push(int v)
{
    if (v && D[v])
    {
        A[v] += D[v];
        D[L[v]] += D[v];
        D[R[v]] += D[v];
        D[v] = 0;
    }
}

void spliti(int v, int *l, int *r, int ind)
{
    if (!v) { *l=*r=0; return; }
    push(v);

    if (S[L[v]] < ind)
    {
        spliti(R[v], R+v, r, ind - S[L[v]] - 1);
        *l = v;
    }
    else
    {
        spliti(L[v], l, L+v, ind);
        *r = v;
    }
    pull(v);
}

void merge(int *v, int l, int r)
{
    if (!l || !r) { *v = l^r; return; }

    push(l), push(r);

    if (B[l] < B[r])
    {
        merge(L+r, l, L[r]);
        *v = r;
    }
    else
    {
        merge(R+l, R[l], r);
        *v = l;
    }

    pull(*v);
}

int order(int v, int k)
{
    if (!v) return 0;

    push(v);
    if (A[v] < k) return 1 + S[L[v]] + order(R[v], k);
    return order(L[v], k);
}

int n, q, t;
char op;

INLINE int H(int v)
{
    int c = v;
    while (R[c]) c = R[c];
    return A[c];
}

INLINE void fertilize(int s, int h)
{
    int j = order(t, h);
    int y1 = 0, y2 = 0, y3 = 0, y4 = 0, y5 = 0, y6 = 0, y7 = 0, y8 = 0;
    spliti(t, &y1, &y2, j);
    spliti(y2, &y3, &y4, s);
    int x = H(y3);
    int aa = S[y3] - order(y3, x);
    int bb = order(y4, x+1);
    spliti(y3, &y5, &y6, S[y3] - aa);
    spliti(y4, &y7, &y8, bb);

    ++D[y5]; ++D[y6];
    push(y5);
    push(y6);

    merge(&y4, y6, y8);
    merge(&y3, y5, y7);
    merge(&y2, y3, y4);
    merge(&t, y1, y2);
}

INLINE void query(int x, int y)
{
    printf("%d\n", order(t, y+1) - order(t, x));
}

int main(void)
{
    scanf("%d%d", &n, &q);
    int a[N];
    for (int i = 0; i < n; ++i) scanf("%d", a+i);
    std::sort(a, a+n);
    for (int i = 0; i < n; ++i) merge(&t, t, treap(a[i]));

    for (int x, y, i = 0; i < q; ++i)
    {
        scanf(" %c%d%d", &op, &x, &y);
        if (op == 'F') fertilize(x, y);
        else query(x, y);
    }
    return 0;
}

Compilation message

grow.cpp: In function 'int main()':
grow.cpp:130:10: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  130 |     scanf("%d%d", &n, &q);
      |     ~~~~~^~~~~~~~~~~~~~~~
grow.cpp:132:38: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  132 |     for (int i = 0; i < n; ++i) scanf("%d", a+i);
      |                                 ~~~~~^~~~~~~~~~~
grow.cpp:138:14: warning: ignoring return value of 'int scanf(const char*, ...)' declared with attribute 'warn_unused_result' [-Wunused-result]
  138 |         scanf(" %c%d%d", &op, &x, &y);
      |         ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 99 ms 2920 KB Output is correct
2 Correct 117 ms 2900 KB Output is correct
3 Correct 71 ms 2740 KB Output is correct

Subtask #2
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 1 ms 860 KB Output is correct
2 Correct 2 ms 860 KB Output is correct
3 Correct 2 ms 856 KB Output is correct
4 Correct 1 ms 860 KB Output is correct
5 Correct 38 ms 1064 KB Output is correct
6 Correct 47 ms 1232 KB Output is correct
7 Correct 5 ms 860 KB Output is correct
8 Correct 22 ms 1116 KB Output is correct

Subtask #3
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 42 ms 1300 KB Output is correct
2 Correct 51 ms 1112 KB Output is correct
3 Correct 2 ms 860 KB Output is correct
4 Correct 27 ms 1116 KB Output is correct

Subtask #4
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 40 ms 1380 KB Output is correct
2 Correct 51 ms 1320 KB Output is correct
3 Correct 8 ms 860 KB Output is correct
4 Correct 49 ms 1140 KB Output is correct

Subtask #5
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 84 ms 2352 KB Output is correct
2 Correct 122 ms 2584 KB Output is correct
3 Correct 14 ms 1116 KB Output is correct
4 Correct 53 ms 2396 KB Output is correct

Subtask #6
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 120 ms 2632 KB Output is correct
2 Correct 118 ms 2720 KB Output is correct
3 Correct 62 ms 2396 KB Output is correct
4 Correct 14 ms 1116 KB Output is correct

Subtask #7
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 107 ms 2748 KB Output is correct
2 Correct 94 ms 2908 KB Output is correct
3 Correct 64 ms 2652 KB Output is correct
4 Correct 14 ms 1116 KB Output is correct

Subtask #8
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 127 ms 3108 KB Output is correct
2 Correct 124 ms 2640 KB Output is correct
3 Correct 32 ms 3164 KB Output is correct
4 Correct 65 ms 3164 KB Output is correct

Subtask #9
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 116 ms 3096 KB Output is correct
2 Correct 102 ms 2896 KB Output is correct
3 Correct 146 ms 3140 KB Output is correct

Subtask #10
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 88 ms 3624 KB Output is correct