oj.uz

Submission #909946

# Submission time Handle Problem Language Result Execution time Memory
909946 2024-01-17T16:13:52 Z danikoynov Progression (NOI20_progression) C++14
70 / 100
 1226 ms 144852 KB 
/**
 ____ ____ ____ ____ ____ ____
||l |||e |||i |||n |||a |||d ||
||__|||__|||__|||__|||__|||__||
|/__\|/__\|/__\|/__\|/__\|/__\|

**/

#include<bits/stdc++.h>
#define endl '\n'

using namespace std;
typedef long long ll;

void speed()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}
const ll maxn = 3e5 + 10;

ll n, q;
ll d[maxn], b[maxn];

void input()
{
    cin >> n >> q;
    for (ll i = 1; i <= n; i ++)
    {
        cin >> d[i];
        b[i] = d[i] - d[i - 1];
    }
}

ll query(ll l, ll r)
{
    if (l == r)
        return 1;

    ll cnt = 1, mx = 0;
    for (ll i = l + 2; i <= r; i ++)
    {
        if (b[i] == b[i -1])
            cnt ++;
        else
        {
            if (cnt > mx)
                mx = cnt;
            cnt = 1;
        }
    }
    if (cnt > mx)
        mx = cnt;
    return mx + 1;
}

const ll inf = 2e18;

struct line
{
    ll k, m;

    line(ll _k = 0, ll _m = -inf)
    {
        k = _k;
        m = _m;
    }

    ll math(ll x)
    {
        return k * x + m;
    }

    void add_line(line cur)
    {
        k += cur.k;
        m += cur.m;
    }

    void set_line(line cur)
    {
        k = cur.k;
        m = cur.m;
    }
};

line set_lazy[4 * maxn], add_lazy[4 * maxn];
ll set_tag[4 * maxn], add_tag[4 * maxn];

void push_lazy(ll root, ll left, ll right)
{
    ll mid = (left + right) / 2;
    if (set_tag[root] == 1)
    {
        ///li_chao[root].set_line(set_lazy[root]);
        if (left != right)
        {
            set_tag[root * 2] = 1;
            set_tag[root * 2 + 1] = 1;
            add_tag[root * 2] = 0;
            add_tag[root * 2 + 1] = 0;
            set_lazy[root * 2] = set_lazy[root];
            set_lazy[root * 2 + 1] = set_lazy[root];
            add_lazy[root * 2] = line(0, 0);
            add_lazy[root * 2 + 1] = line(0, 0);
        }
        else
        {
            d[left] = set_lazy[root].math(left);
        }
        set_tag[root] = 0;
        set_lazy[root] = line(0, 0);
    }
    if (add_tag[root] == 1)
    {

        if (left != right)
        {
            add_tag[root * 2] = 1;
            add_tag[root * 2 + 1] = 1;
            add_lazy[root * 2].add_line(add_lazy[root]);
            add_lazy[root * 2 + 1].add_line(add_lazy[root]);
        }
                else
        {
            d[left] += add_lazy[root].math(left);
        }
        add_tag[root] = 0;
        add_lazy[root] = line(0, 0);
    }
}

void set_line(ll root, ll left, ll right, ll qleft, ll qright, line cur)
{
    push_lazy(root, left, right);
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        set_tag[root] = 1;
        set_lazy[root] = cur;
        push_lazy(root, left, right);
        return;
    }

    ll mid = (left + right) / 2;
    set_line(root * 2, left, mid, qleft, qright, cur);
    set_line(root * 2 + 1, mid + 1, right, qleft, qright, cur);
}

void add_line(ll root, ll left, ll right, ll qleft, ll qright, line cur)
{
    push_lazy(root, left, right);
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        add_tag[root] = 1;
        add_lazy[root] = cur;
        push_lazy(root, left, right);
        return;
    }

    ll mid = (left + right) / 2;
    add_line(root * 2, left, mid, qleft, qright, cur);
    add_line(root * 2 + 1, mid + 1, right, qleft, qright, cur);
}


ll query(ll root, ll left, ll right, ll pos)
{
    push_lazy(root, left, right);
    if (left == right)
        return d[left];

    ll mid = (left + right) / 2;
    if (pos <= mid)
        return query(root * 2, left, mid, pos);
    return query(root * 2 + 1, mid + 1, right, pos);
}
/**void add_line_concious(ll root, ll left, ll right, line cur)
{
    push_lazy(root, left, right);
    ll mid = (left + right) / 2;
    if (li_chao[root].math(mid) < cur.math(mid))
        swap(li_chao[root], cur);

    if (left == right)
        return;

    if ()
}*/

struct node
{
    ll pref, suff, lon, len;
    ll fs, ls;

    node(ll _pref = 0, ll _suff = 0, ll _lon = 0, ll _fs = -inf, ll _ls = inf, ll _len = 0)
    {
        len = _len;
        pref = _pref;
        suff = _suff;
        lon = _lon;
        fs = _fs;
        ls = _ls;
    }
};

node merge_nodes(node lf, node rf)
{
    if (lf.ls == inf)
    return rf;
    if (rf.fs == -inf)
        return lf;

    node mf;
    mf.fs = lf.fs;
    mf.ls = rf.ls;

    mf.pref = lf.pref;
    if (lf.pref == lf.len && lf.ls == rf.fs)
        mf.pref += rf.pref;
    mf.suff = rf.suff;
    if (rf.suff == rf.len && rf.fs == lf.ls)
        mf.suff += lf.suff;

    mf.lon = max(lf.lon, rf.lon);
    if (lf.ls == rf.fs)
        mf.lon = max(mf.lon, lf.suff + rf.pref);

    mf.len = lf.len + rf.len;
    return mf;
}

node tree[4 * maxn];

pair < ll, ll > lazy[4 * maxn];
pair < ll, ll > tag[4 * maxn];
void make_lazy(ll root, ll left, ll right)
{
    if (tag[root].first)
    {
        ll len = right - left + 1;
        tree[root] = node(len, len, len, lazy[root].first, lazy[root].first, len);
        if (left != right)
        {
            tag[root * 2].first = 1;
            tag[root * 2 + 1].first = 1;
            tag[root * 2].second = 0;
            tag[root * 2 + 1].second = 0;
            lazy[root * 2].second = 0;
            lazy[root * 2 + 1].second = 0;

            lazy[root * 2].first = lazy[root].first;
            lazy[root * 2 + 1].first = lazy[root].first;
        }
        lazy[root].first = 0;
        tag[root].first = 0;
    }
    if (tag[root].second)
    {
        tree[root].fs += lazy[root].second;
        tree[root].ls += lazy[root].second;
        if (left != right)
        {
            tag[root * 2].second = 1;
            tag[root * 2 + 1].second = 1;
            lazy[root * 2].second += lazy[root].second;
            lazy[root * 2 + 1].second += lazy[root].second;
        }
        tag[root].second = 0;
        lazy[root].second = 0;
    }
}

void range_update_set(ll root, ll left, ll right, ll qleft, ll qright, ll val)
{
    make_lazy(root, left, right);
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        lazy[root].first = val;
        tag[root].first = 1;
        make_lazy(root, left, right);
        return;
    }

    ll mid = (left + right) / 2;
    range_update_set(root * 2, left, mid, qleft, qright, val);
    range_update_set(root * 2 + 1, mid + 1, right, qleft, qright, val);

    tree[root] = merge_nodes(tree[root * 2], tree[root * 2 + 1]);
}

void range_update_add(ll root, ll left, ll right, ll qleft, ll qright, ll val)
{
    make_lazy(root, left, right);
    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        lazy[root].second =val;
        tag[root].second = 1;
        make_lazy(root, left, right);
        return;
    }

    ll mid = (left + right) / 2;
    range_update_add(root * 2, left, mid, qleft, qright, val);
    range_update_add(root * 2 + 1, mid + 1, right, qleft, qright, val);

    tree[root] = merge_nodes(tree[root * 2], tree[root * 2 + 1]);
}

node query_range(ll root, ll left, ll right, ll qleft, ll qright)
{
    make_lazy(root, left, right);
    if (left > qright || right < qleft)
        return node();

    if (left >= qleft && right <= qright)
    {
        return tree[root];
    }

    ll mid = (left + right) / 2;
    return merge_nodes(query_range(root * 2, left, mid, qleft, qright),
                       query_range(root * 2 + 1, mid + 1, right, qleft, qright));
}

void build_tree(ll root, ll left, ll right)
{
    if (left == right)
    {
        tree[root] = node(1, 1, 1, b[left], b[left], 1);
        return;
    }

    ll mid = (left + right) / 2;
    build_tree(root * 2, left, mid);
    build_tree(root * 2 + 1, mid + 1, right);

    tree[root] = merge_nodes(tree[root * 2], tree[root * 2 + 1]);
}

void simulate()
{
    build_tree(1, 1, n);
    for (ll i = 1; i <= q; i ++)
    {
        ll type, l, r;
        ll s, c;
        cin >> type >> l >> r;
        if (type == 3)
        {
            node cur = query_range(1, 1, n, l + 1, r);
            cout << cur.lon + 1 << endl;
            ///cout << query(l, r) << endl;
        }
        else if (type == 1)
        {
            cin >> s >> c;
            add_line(1, 1, n, l, r, line(c, - l * c + s));
            /*for (ll j = l; j <= r; j ++)
            {
                d[j] += s + (ll)(j - l) * c;
            }*/
            range_update_add(1, 1, n, l + 1, r, c);
            range_update_add(1, 1, n, l, l, s);
            //b[l] += s;
            //for (ll j = l + 1; j <= r; j ++)
              //  b[j] += c;
                if (r + 1 <= n)
            range_update_set(1, 1, n, r + 1, r + 1, query(1, 1, n, r + 1) - query(1, 1, n, r));
           // b[r + 1] = query(1, 1, n, r + 1) - query(1, 1, n, r); ///d[r + 1] - d[r];
        }
        else
        {
            cin >> s >> c;
            set_line(1, 1, n, l, r, line(c, - l * c + s));
            /**for (ll j = l; j <= r; j ++)
            {
                d[j] = s + (ll)(j - l) * c;
            }*/
            range_update_set(1, 1, n, l + 1, r, c);
            //for (ll j = l + 1; j <= r; j ++)
              //  b[j] = c;
            range_update_set(1, 1, n, l, l, query(1, 1, n, l) - query(1, 1, n, l - 1));
            ///b[l] = query(1, 1, n, l) - query(1, 1, n, l - 1); ///d[l] - d[l - 1];
            if (r + 1 <= n)
            range_update_set(1, 1, n, r + 1, r + 1, query(1, 1, n, r + 1) - query(1, 1, n, r));
            //b[r + 1] = query(1, 1, n, r + 1) - query(1, 1, n, r); ///d[r + 1] - d[r];
        }

        /**for (ll j = 2; j <= n; j ++)
        {
            if (b[j] != query_range(1, 1, n, j, j).fs)
            {
                while(true);
            }
        }*/
        /**for (ll j = 1; j <= n; j ++)
        {

            b[j] = d[j] - d[j - 1];
        }*/
        /**for (ll j = 1; j <= n; j ++)
            cout << d[j] << " ";
        cout << endl;*/
    }
}
void solve()
{
    input();
    simulate();
}

int main()
{
    speed();
    solve();
    return 0;
}

Compilation message

Progression.cpp: In function 'void push_lazy(ll, ll, ll)':
Progression.cpp:93:8: warning: unused variable 'mid' [-Wunused-variable]
   93 |     ll mid = (left + right) / 2;
      |        ^~~

Subtask #1
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 366 ms 118908 KB Output is correct
2 Correct 143 ms 103240 KB Output is correct
3 Correct 139 ms 103248 KB Output is correct
4 Correct 142 ms 103252 KB Output is correct
5 Correct 139 ms 103252 KB Output is correct
6 Correct 139 ms 103188 KB Output is correct
7 Correct 147 ms 103336 KB Output is correct
8 Correct 19 ms 103000 KB Output is correct
9 Correct 19 ms 102968 KB Output is correct
10 Correct 19 ms 103004 KB Output is correct
11 Correct 364 ms 119032 KB Output is correct
12 Correct 360 ms 118868 KB Output is correct
13 Correct 362 ms 119084 KB Output is correct
14 Correct 366 ms 119120 KB Output is correct
15 Correct 363 ms 119312 KB Output is correct
16 Correct 367 ms 118868 KB Output is correct
17 Correct 363 ms 118828 KB Output is correct
18 Correct 366 ms 118872 KB Output is correct

Subtask #2
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 21 ms 103000 KB Output is correct
2 Correct 20 ms 103004 KB Output is correct
3 Correct 19 ms 103000 KB Output is correct
4 Correct 20 ms 103000 KB Output is correct
5 Correct 19 ms 103000 KB Output is correct
6 Correct 20 ms 103004 KB Output is correct
7 Correct 19 ms 103000 KB Output is correct
8 Correct 20 ms 103000 KB Output is correct
9 Correct 20 ms 103004 KB Output is correct
10 Correct 20 ms 103004 KB Output is correct
11 Correct 20 ms 103156 KB Output is correct
12 Correct 21 ms 103008 KB Output is correct
13 Correct 19 ms 103004 KB Output is correct
14 Correct 20 ms 103004 KB Output is correct
15 Correct 21 ms 102988 KB Output is correct
16 Correct 22 ms 102952 KB Output is correct
17 Correct 22 ms 103004 KB Output is correct
18 Correct 20 ms 103004 KB Output is correct
19 Correct 20 ms 103004 KB Output is correct
20 Correct 20 ms 103004 KB Output is correct
21 Correct 20 ms 103000 KB Output is correct

Subtask #3
35.0 / 35.0

# Verdict Execution time Memory Grader output
1 Correct 320 ms 102816 KB Output is correct
2 Correct 101 ms 101456 KB Output is correct
3 Correct 100 ms 101380 KB Output is correct
4 Correct 98 ms 101460 KB Output is correct
5 Correct 102 ms 101456 KB Output is correct
6 Correct 100 ms 101560 KB Output is correct
7 Correct 100 ms 101456 KB Output is correct
8 Correct 19 ms 100816 KB Output is correct
9 Correct 19 ms 100796 KB Output is correct
10 Correct 18 ms 100956 KB Output is correct
11 Correct 369 ms 102848 KB Output is correct
12 Correct 315 ms 102956 KB Output is correct
13 Correct 359 ms 102896 KB Output is correct
14 Correct 320 ms 102708 KB Output is correct
15 Correct 314 ms 103248 KB Output is correct
16 Correct 338 ms 103252 KB Output is correct
17 Correct 324 ms 103272 KB Output is correct
18 Correct 351 ms 103412 KB Output is correct
19 Correct 317 ms 102992 KB Output is correct
20 Correct 290 ms 102552 KB Output is correct
21 Correct 297 ms 102484 KB Output is correct

Subtask #4
11.0 / 11.0

# Verdict Execution time Memory Grader output
1 Correct 963 ms 140844 KB Output is correct
2 Correct 183 ms 103252 KB Output is correct
3 Correct 183 ms 103248 KB Output is correct
4 Correct 189 ms 103240 KB Output is correct
5 Correct 185 ms 103180 KB Output is correct
6 Correct 182 ms 103004 KB Output is correct
7 Correct 192 ms 103368 KB Output is correct
8 Correct 19 ms 103012 KB Output is correct
9 Correct 19 ms 103000 KB Output is correct
10 Correct 20 ms 103000 KB Output is correct
11 Correct 916 ms 140676 KB Output is correct
12 Correct 912 ms 140692 KB Output is correct
13 Correct 915 ms 140612 KB Output is correct
14 Correct 926 ms 140456 KB Output is correct
15 Correct 886 ms 140524 KB Output is correct
16 Correct 928 ms 140500 KB Output is correct
17 Correct 942 ms 140688 KB Output is correct
18 Correct 958 ms 140896 KB Output is correct
19 Correct 914 ms 140648 KB Output is correct
20 Correct 889 ms 140644 KB Output is correct
21 Correct 914 ms 140624 KB Output is correct

Subtask #5
0 / 13.0

# Verdict Execution time Memory Grader output
1 Correct 320 ms 102816 KB Output is correct
2 Correct 101 ms 101456 KB Output is correct
3 Correct 100 ms 101380 KB Output is correct
4 Correct 98 ms 101460 KB Output is correct
5 Correct 102 ms 101456 KB Output is correct
6 Correct 100 ms 101560 KB Output is correct
7 Correct 100 ms 101456 KB Output is correct
8 Correct 19 ms 100816 KB Output is correct
9 Correct 19 ms 100796 KB Output is correct
10 Correct 18 ms 100956 KB Output is correct
11 Correct 369 ms 102848 KB Output is correct
12 Correct 315 ms 102956 KB Output is correct
13 Correct 359 ms 102896 KB Output is correct
14 Correct 320 ms 102708 KB Output is correct
15 Correct 314 ms 103248 KB Output is correct
16 Correct 338 ms 103252 KB Output is correct
17 Correct 324 ms 103272 KB Output is correct
18 Correct 351 ms 103412 KB Output is correct
19 Correct 317 ms 102992 KB Output is correct
20 Correct 290 ms 102552 KB Output is correct
21 Correct 297 ms 102484 KB Output is correct
22 Correct 1226 ms 144852 KB Output is correct
23 Incorrect 183 ms 103240 KB Output isn't correct
24 Halted 0 ms 0 KB -

Subtask #6
0 / 17.0

# Verdict Execution time Memory Grader output
1 Correct 366 ms 118908 KB Output is correct
2 Correct 143 ms 103240 KB Output is correct
3 Correct 139 ms 103248 KB Output is correct
4 Correct 142 ms 103252 KB Output is correct
5 Correct 139 ms 103252 KB Output is correct
6 Correct 139 ms 103188 KB Output is correct
7 Correct 147 ms 103336 KB Output is correct
8 Correct 19 ms 103000 KB Output is correct
9 Correct 19 ms 102968 KB Output is correct
10 Correct 19 ms 103004 KB Output is correct
11 Correct 364 ms 119032 KB Output is correct
12 Correct 360 ms 118868 KB Output is correct
13 Correct 362 ms 119084 KB Output is correct
14 Correct 366 ms 119120 KB Output is correct
15 Correct 363 ms 119312 KB Output is correct
16 Correct 367 ms 118868 KB Output is correct
17 Correct 363 ms 118828 KB Output is correct
18 Correct 366 ms 118872 KB Output is correct
19 Correct 21 ms 103000 KB Output is correct
20 Correct 20 ms 103004 KB Output is correct
21 Correct 19 ms 103000 KB Output is correct
22 Correct 20 ms 103000 KB Output is correct
23 Correct 19 ms 103000 KB Output is correct
24 Correct 20 ms 103004 KB Output is correct
25 Correct 19 ms 103000 KB Output is correct
26 Correct 20 ms 103000 KB Output is correct
27 Correct 20 ms 103004 KB Output is correct
28 Correct 20 ms 103004 KB Output is correct
29 Correct 20 ms 103156 KB Output is correct
30 Correct 21 ms 103008 KB Output is correct
31 Correct 19 ms 103004 KB Output is correct
32 Correct 20 ms 103004 KB Output is correct
33 Correct 21 ms 102988 KB Output is correct
34 Correct 22 ms 102952 KB Output is correct
35 Correct 22 ms 103004 KB Output is correct
36 Correct 20 ms 103004 KB Output is correct
37 Correct 20 ms 103004 KB Output is correct
38 Correct 20 ms 103004 KB Output is correct
39 Correct 20 ms 103000 KB Output is correct
40 Correct 320 ms 102816 KB Output is correct
41 Correct 101 ms 101456 KB Output is correct
42 Correct 100 ms 101380 KB Output is correct
43 Correct 98 ms 101460 KB Output is correct
44 Correct 102 ms 101456 KB Output is correct
45 Correct 100 ms 101560 KB Output is correct
46 Correct 100 ms 101456 KB Output is correct
47 Correct 19 ms 100816 KB Output is correct
48 Correct 19 ms 100796 KB Output is correct
49 Correct 18 ms 100956 KB Output is correct
50 Correct 369 ms 102848 KB Output is correct
51 Correct 315 ms 102956 KB Output is correct
52 Correct 359 ms 102896 KB Output is correct
53 Correct 320 ms 102708 KB Output is correct
54 Correct 314 ms 103248 KB Output is correct
55 Correct 338 ms 103252 KB Output is correct
56 Correct 324 ms 103272 KB Output is correct
57 Correct 351 ms 103412 KB Output is correct
58 Correct 317 ms 102992 KB Output is correct
59 Correct 290 ms 102552 KB Output is correct
60 Correct 297 ms 102484 KB Output is correct
61 Correct 963 ms 140844 KB Output is correct
62 Correct 183 ms 103252 KB Output is correct
63 Correct 183 ms 103248 KB Output is correct
64 Correct 189 ms 103240 KB Output is correct
65 Correct 185 ms 103180 KB Output is correct
66 Correct 182 ms 103004 KB Output is correct
67 Correct 192 ms 103368 KB Output is correct
68 Correct 19 ms 103012 KB Output is correct
69 Correct 19 ms 103000 KB Output is correct
70 Correct 20 ms 103000 KB Output is correct
71 Correct 916 ms 140676 KB Output is correct
72 Correct 912 ms 140692 KB Output is correct
73 Correct 915 ms 140612 KB Output is correct
74 Correct 926 ms 140456 KB Output is correct
75 Correct 886 ms 140524 KB Output is correct
76 Correct 928 ms 140500 KB Output is correct
77 Correct 942 ms 140688 KB Output is correct
78 Correct 958 ms 140896 KB Output is correct
79 Correct 914 ms 140648 KB Output is correct
80 Correct 889 ms 140644 KB Output is correct
81 Correct 914 ms 140624 KB Output is correct
82 Correct 1226 ms 144852 KB Output is correct
83 Incorrect 183 ms 103240 KB Output isn't correct
84 Halted 0 ms 0 KB -