评测记录

WA 65（WA on #7，#9-14）

分布得让我不知道从何入手调试。

马蜂优良，轻微压行，函数/变量名清晰明了（

#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x)
{
    x = 0;
    register char c = getchar();
    register short f = 1;
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
        c = getchar();
    }
    x *= f;
}

template <typename T, typename... Args>
inline void read(T &x, Args &...temps)
{
    read(x), read(temps...);
}

const int N = 3e5 + 5;
typedef long long ll;
int n, q, c1, c2, w1, w2;
int a[N];

struct BinaryTree
{
    ll t[N];
    void add(int x, ll k)
    {
        for (; x <= n; x += x & -x)
            t[x] += k;
    }
    ll query(int x)
    {
        ll ret = 0;
        for (; x; x -= x & -x)
            ret += t[x];
        return ret;
    }
} bt;

ll sum[N];

struct SegmentTree
{
    int L[N << 2], R[N << 2];
    ll Max[N << 2], val[N << 2], tag[N << 2];
#define lt (p << 1)
#define rt (p << 1 | 1)
    void max_push_up(int p)
    {
        Max[p] = max(Max[lt], Max[rt]);
    }
    void val_push_up(int p)
    {
        val[p] = max(val[lt], val[rt]);
    }
    void build(int p, int l, int r)
    {
        L[p] = l, R[p] = r;
        if (l == r)
        {
            Max[p] = a[l];
            val[p] = sum[min(n, l + c2 - 1)] - sum[l - 1];
            return;
        }
        int mid = l + r >> 1;
        build(lt, l, mid);
        build(rt, mid + 1, r);
        max_push_up(p);
        val_push_up(p);
    }
    void max_modify(int p, int x, ll k)
    {
        if (L[p] == R[p])
        {
            Max[x] += k;
            return;
        }
        int mid = L[p] + R[p] >> 1;
        if (mid >= x)
            max_modify(lt, x, k);
        else
            max_modify(rt, x, k);
        max_push_up(p);
    }
    ll max_query(int p, int l, int r)
    {
        if (l <= L[p] && R[p] <= r)
            return Max[p];
        int mid = L[p] + R[p] >> 1;
        ll ret = 0;
        if (mid >= l)
            ret = max(ret, max_query(lt, l, r));
        if (mid < r)
            ret = max(ret, max_query(rt, l, r));
        return ret;
    }
    void push_down(int p)
    {
        if (tag[p])
        {
            tag[lt] += tag[p];
            tag[rt] += tag[p];
            val[lt] += tag[p];
            val[rt] += tag[p];
            tag[p] = 0;
        }
    }
    void val_modify(int p, int l, int r, ll k)
    {
        if (l <= L[p] && R[p] <= r)
        {
            val[p] += k;
            tag[p] += k;
            return;
        }
        push_down(p);
        int mid = L[p] + R[p] >> 1;
        if (mid >= l)
            val_modify(lt, l, r, k);
        if (mid < r)
            val_modify(rt, l, r, k);
        val_push_up(p);
    }
    int Lval_query(int p, int l, int r)
    {
        if (L[p] == R[p])
            return L[p];
        push_down(p);
        int mid = L[p] + R[p] >> 1;
        if (mid >= l && val[lt] > w2)
            return Lval_query(lt, l, r);
        if (mid < r && val[rt] > w2)
            return Lval_query(rt, l, r);
        return N;
    }
    int Rval_query(int p, int l, int r)
    {
        if (L[p] == R[p])
            return L[p];
        push_down(p);
        int mid = L[p] + R[p] >> 1;
        if (mid < r && val[rt] > w2)
            return Rval_query(rt, l, r);
        if (mid >= l && val[lt] > w2)
            return Rval_query(lt, l, r);
        return N;
    }
#undef lt
#undef rt
} seg;

signed main()
{
    read(n, q, c1, c2, w1, w2);
    for (int i = 1; i <= n; i++)
    {
        read(a[i]);
        bt.add(i, a[i]);
        sum[i] = sum[i - 1] + a[i];
    }
    seg.build(1, 1, n);
    for (int op, x, y; q--;)
    {
        read(op, x, y);
        if (op == 1)
        {
            bt.add(x, y);
            seg.max_modify(1, x, y);
            seg.val_modify(1, max(1, x - c2 + 1), x, y);
        }
        else
        {
            int len = y - x + 1;
            if (len < c2)
            {
                ll tot = bt.query(y) - bt.query(x - 1);
                if (len <= c1 && tot <= w1)
                    puts("cont");
                else
                {
                    if (tot > w2)
                        puts("tetris");
                    else
                        puts(seg.max_query(1, x, y) <= w1 ? "cont" : "tetris");
                }
            }
            else
            {
                int L = seg.Lval_query(1, x, y - c2 + 1);
                int R = seg.Rval_query(1, x, y - c2 + 1);
                if (L > n)
                    puts(seg.max_query(1, x, y) <= w1 ? "cont" : "tetris");
                else
                {
                    R = R + c2 - 1;
                    ll tot = bt.query(R) - bt.query(L - 1);
                    if ((R - L + 1) <= c1 && tot <= w1)
                        puts("cont");
                    else
                        puts("tetris");
                }
            }
        }
    }

    return 0;
}