Submission #1010682

#	Time	Username	Problem	Language	Result	Execution time	Memory
1010682		danikoynov	Triple Jump (JOI19_jumps)	C++14	100 / 100	905 ms	109236 KiB

jumps

#include<bits/stdc++.h>
#define endl '\n'
const int MAX_N = 5e5 + 10;


int n, q, a[MAX_N];
void input()
{
    std::cin >> n;
    for (int i = 1; i <= n; i ++)
        std::cin >> a[i];
}

std::vector < std::pair < int, int > > fun;

void precompute_pairs()
{
    std::stack < int > st;
    for (int i = n; i > 0; i --)
    {
        while(!st.empty() && a[st.top()] <= a[i])
        {
            fun.push_back({i, st.top()});
            st.pop();
        }
        st.push(i);
    }

    while(!st.empty())
        st.pop();
    for (int i = 1; i <= n; i ++)
    {
        while(!st.empty() && a[st.top()] <= a[i])
        {
            ///std::cout << "pop " << st.top() << " from " << i << endl;
            fun.push_back({st.top(), i});
            st.pop();
        }
        st.push(i);
    }  
}

int fp[MAX_N];

void single_query(int l, int r)
{
    fp[r + 1] = 0;
    for (int i = r; i >= l; i --)
    {
        fp[i] = std::max(fp[i + 1], a[i]);
    }

    int res = 0;
    for (std::pair < int, int > cur : fun)
    {
        int id = 2 * cur.second - cur.first;
        if (id > r || cur.first < l)
            continue;
        //std::cout << "query " << cur.first << " " << cur.second << " " << id << endl;
        res = std::max(res, a[cur.first] + a[cur.second] + fp[id]);
    }

    /**for (int i = l; i <= r; i ++)
        for (int f = i + 1; f <= r; f ++)
            for (int j = 2 * f - i; j <= r; j ++)
            {
                if (a[i] + a[j] + a[f] == 174)
                    std::cout << "winner " << i << " " << f << " " << j << endl;
            }*/
    std::cout << res << endl;
}

struct Query
{
    int l, r, id;

    Query(int _l = 0, int _r = 0, int _id = 0)
    {
        l = _l;
        r = _r;
        id = _id;
    }
};

const int INF = 1e9 + 10; 

std::vector < std::pair < int, int > > task[MAX_N];
int ans[MAX_N];

/**tree[4 * MAX_N];

void range_update(int root, int left, int right, int qleft, int qright, int val)
{
    push_lazy(root, left, right);

    if (left > qright || right < qleft)
        return;

    if (left >= qleft && right <= qright)
    {
        lazy[root] = val;
        push_lazy(root, left, right);
        return;
    }

    int mid = (left + right) / 2;
    range_update(root * 2, left, mid, qleft, qright);
    range_update(root * 2 + 1, mid + 1, right, qleft, qright);

    tree[root] = std::max(tree[root * 2], tree[root * 2 + 1]);
}*/

struct Node
{
    int p, d, res;

    Node(int _p = -INF, int _d = -INF, int _res = 0)
    {
        p = _p;
        d = _d;
        res = _res;
    }
};
Node tree[4 * MAX_N];

Node merge(Node lf, Node rf)
{
    Node mf;
    mf.d = std::max(lf.d, rf.d);
    mf.p = std::max(lf.p, rf.p);
    mf.res = std::max(lf.res, rf.res);
    mf.res = std::max(mf.res, lf.p + rf.d);
    return mf;
}

void build(int root, int left, int right)
{
    if (left == right)
    {
        tree[root].d = a[left];
        return;
    }

    int mid = (left + right) / 2;
    build(root * 2, left, mid);
    build(root * 2 + 1, mid + 1, right);

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

void update(int root, int left, int right, int pivot, int val)
{
    if (left == right)
    {
        tree[root].p = std::max(tree[root].p, val);
        tree[root].res = tree[root].d + tree[root].p;
        return;
    }

    int mid = (left + right) / 2;
    if (pivot <= mid)
        update(root * 2, left, mid, pivot, val);
    else
        update(root * 2 + 1, mid + 1, right, pivot, val);

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

Node query(int root, int left, int right, int qleft, int qright)
{
    if (left > qright || right < qleft)
        return Node();
    if (left >= qleft && right <= qright)   
        return tree[root];

    int mid = (left + right) / 2;
    return merge(query(root * 2, left, mid, qleft, qright),
                query(root * 2 + 1, mid + 1, right, qleft, qright));
}

std::vector < std::pair < int, int > > spot[MAX_N];
void answer_queries()
{
    std::cin >> q;
    for (int i = 1; i <= q; i ++)
    {
        int l, r;
        std::cin >> l >> r;
        task[l].push_back({r, i});
    }

    for (std::pair < int, int > cur : fun)
    {
        spot[cur.first].push_back({2 * cur.second - cur.first, a[cur.first] + a[cur.second]});
    }

    build(1, 1, n);
    for (int i = n; i > 0; i --)
    {
        for (std::pair < int, int > cur : spot[i])
        {
            if (cur.first > n)
                continue;

            update(1, 1, n, cur.first, cur.second);
            ///std::cout << "update " << i << " " << cur.first << " " << cur.second << endl;
        }   

        for (std::pair < int, int > cur : task[i])
        {
            Node tk = query(1, 1, n, i, cur.first);
            ans[cur.second] = tk.res;
        }
    }

    for (int i = 1; i <= q; i ++)
        std::cout << ans[i] << endl;
}


void solve()
{
    input();
    precompute_pairs();
    answer_queries();
}

void speed()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}
int main()
{   
    speed();
    solve();
    return 0;
}
/*
15
12 96 100 61 54 66 37 34 58 21 21 1 13 50 81
1
6 14
*/

• Subtask 1: 5 / 5
• Subtask 2: 14 / 14
• Subtask 3: 27 / 27
• Subtask 4: 54 / 54