Submission #219892

#	Time	Username	Problem	Language	Result	Execution time	Memory
219892		emil_physmath	Shortcut (IOI16_shortcut)	C++17	31 / 100	2089 ms	632 KiB

shortcut

#include "shortcut.h"
#include <algorithm>
#include <iostream>
#include <vector>
#include <set>
using namespace std;
using llong  = long long;
const int maxN = 3001;

llong t3[4 * maxN], t4[4 * maxN], lazy3[4 * maxN], lazy4[4 * maxN];
llong t1[4 * maxN], t2[4 * maxN], lazy1[4 * maxN], lazy2[4 * maxN];
vector<llong> x, val;
llong c;

void Build(llong* t, llong* lazy, int v, int vl, int vr, const vector<llong>& a)
{
    lazy[v] = 0;
    if (vl == vr)
    {
        t[v] = a[vr];
        return;
    }
    int vm = (vl + vr) / 2;
    Build(t, lazy, v * 2, vl, vm, a);
    Build(t, lazy, v * 2 + 1, vm + 1, vr, a);
    t[v] = max(t[v * 2], t[v * 2 + 1]);
}
void Push(llong* t, llong* lazy, int v, int vl, int vr)
{
    if (lazy[v])
    {
        if (vl != vr)
        {
            lazy[v * 2] += lazy[v];
            lazy[v * 2 + 1] += lazy[v];
        }
        t[v] += lazy[v];
        lazy[v] = 0;
    }
}
void Add(llong* t, llong* lazy, int v, int vl, int vr, int l, int r, llong val)
{
    if (l > vr || vl > r)
        return;
    if (l <= vl && vr <= r)
    {
        lazy[v] += val;
        return;
    }
    Push(t, lazy, v, vl, vr);
    int vm = (vl + vr) / 2;
    Add(t, lazy, v * 2, vl, vm, l, r, val);
    Add(t, lazy, v * 2 + 1, vm + 1, vr, l, r, val);
    Push(t, lazy, v * 2, vl, vm);
    Push(t, lazy, v * 2 + 1, vm + 1, vr);
    t[v] = max(t[v * 2], t[v * 2 + 1]);
}
llong Max(llong* t, llong* lazy, int v, int vl, int vr, int l, int r)
{
    if (vl > r || l > vr)
        return numeric_limits<llong>::min();
    Push(t, lazy, v, vl, vr);
    if (l <= vl && vr <= r)
        return t[v];
    int vm = (vl + vr) / 2;
    return max(Max(t, lazy, v * 2, vl, vm, l, r), Max(t, lazy, v * 2 + 1, vm + 1, vr, l, r));
}
bool Poss(int s, int e, llong cur)
{
    multiset<llong> mx;
    for (int l = s, r = s - 1; l <= e; ++l)
    {
        if (r < l)
        {
            r = l;
            mx.clear();
        }
        else
            mx.erase(mx.find(x[l] + val[l]));
        while (r + 1 <= e && x[r + 1] - x[l] <= (x[e] - x[s]) - (x[r + 1] - x[l]) + c)
        {
            ++r;
            mx.insert(x[r] + val[r]);
        }
        if (mx.size() && *mx.rbegin() - x[l] + val[l] > cur)
            return false;
    }
    mx.clear();
    for (int i = s; i <= e; ++i)
        mx.insert(val[i] - x[i]);
    for (int l = s, r = s; ; ++l)
    {
        while (l > r)
        {
            mx.erase(mx.find(val[r] - x[r]));
            ++r;
            // cerr << "BAAAAAAAAAD?????: l > r\n";
            // exit(0);
        }
        while (r <= e && x[r] - x[l] < (x[e] - x[s]) - (x[r] - x[l]) + c)
        {
            mx.erase(mx.find(val[r] - x[r]));
            ++r;
        }
        if (r > e)
            break;
        if (mx.size() && (x[e] - x[s]) + *mx.rbegin() + x[l] + val[l] + c > cur)
            return false;
    }
    return true;
};
long long Brutos(int n, vector<int> l, vector<int> val, int c)
{
    vector<llong> x(n);
    for (int i = 1; i < n; ++i)
        x[i] = x[i - 1] + l[i - 1];
    llong ans = numeric_limits<llong>::max();
    for (int l = 0; l < n; ++l)
        for (int r = l + 1; r < n; ++r)
        {
            llong cur = 0;
            for (int a = 0; a < n; ++a)
            {
                cur = max(cur, (llong)val[a]);
                for (int b = a + 1; b < n; ++b)
                {
                    if (b <= l || a >= r)
                        cur = max(cur, val[a] + val[b] + x[b] - x[a]);
                    else if (a <= l && b >= r)
                        cur = max(cur, val[a] + val[b] + x[l] - x[a] + x[b] - x[r] + min(x[r] - x[l], (llong)c));
                    else if (l <= a && b <= r)
                        cur = max(cur, val[a] + val[b] + min(x[b] - x[a], x[a] - x[l] + x[r] - x[b] + c));
                    else if (a <= l)
                        cur = max(cur, val[a] + val[b] + x[l] - x[a] + min(x[b] - x[l], x[r] - x[b] + c));
                    else if (b >= r)
                        cur = max(cur, val[a] + val[b] + x[b] - x[r] + min(x[r] - x[a], x[a] - x[l] + c));
                }
            }
            ans = min(ans, cur);
        }
    return ans;
}
long long find_shortcut(int n, vector<int> l, vector<int> val_, int c_)
{
    // return Brutos(n, l, val_, c_);
    // cerr << "Brutos says: " << Brutos(n, l, val_, c_) << '\n';
    // val = val_;
    val.assign(val_.begin(), val_.end());
    c = c_;
    x.resize(n);
    x[0] = 0;
    for (int i = 1; i < n; ++i)
        x[i] = x[i - 1] + l[i - 1];
    vector<llong> pref(n), suff(n), pathpref(n), pathsuff(n);
    pref[0] = val[0];
    pathpref[0] = val[0];
    for (int i = 1; i < n; ++i)
    {
        pathpref[i] = max(pathpref[i - 1], pref[i - 1] + x[i] + val[i]);
        pref[i] = max(pref[i - 1], -x[i] + val[i]);
    }
    suff.back() = val.back();
    pathsuff.back() = val.back();
    for (int i = n - 2; i >= 0; --i)
    {
        pathsuff[i] = max(pathsuff[i + 1], suff[i + 1] + (x.back() - x[i]) + val[i]);
        suff[i] = max(suff[i + 1], -(x.back() - x[i]) + val[i]);
    }
    llong ans_l = *max_element(val.begin(), val.end()), ans_r = (maxN + 2) * 1000'000'000LL;
    llong ans = ans_r + 1;
    while (ans_l <= ans_r)
    {
        llong cur = ans_l + (ans_r - ans_l) / 2;
        bool poss = false;
        for (int l = 0; l < n; ++l)
        {
/*fill(t1, t1 + 4 * n, 0);
fill(lazy1, lazy1 + 4 * n, 0);
fill(t2, t2 + 4 * n, 0);
fill(lazy2, lazy2 + 4 * n, 0);
fill(t3, t3 + 4 * n, 0);
fill(lazy3, lazy3 + 4 * n, 0);
fill(t4, t4 + 4 * n, 0);
fill(lazy4, lazy4 + 4 * n, 0);
for (int i = 0; i < n; ++i)
{
    Add(t1, lazy1, 1, 0, n - 1, i, i, val[i]);
    Add(t2, lazy2, 1, 0, n - 1, i, i, val[i] + c);
    Add(t3, lazy3, 1, 0, n - 1, i, i, val[i]);
    Add(t4, lazy4, 1, 0, n - 1, i, i, val[i] + c);
}*/
vector<llong> valc(val.begin(), val.end());
for (llong& x: valc)
    x += c;
Build(t1, lazy1, 1, 0, n - 1, val);
Build(t2, lazy2, 1, 0, n - 1, valc);
Build(t3, lazy3, 1, 0, n - 1, val);
Build(t4, lazy4, 1, 0, n - 1, valc);
            int r = l, m = l, m1 = l;
            if (cur >= 37 && cur < 39)
                cerr << "";
            if (pathpref[l] > cur)
                break;
            while (r < n)
            {
                /*if (cur == 110 && l == 0 && r == 7)
                {
                    for (int i = l; i <= r; ++i)
                        cerr << "tree1[" << i << "] = " << Max(t1, lazy1, 1, 0, n - 1, i, i) << '\n';
                }*/
                if (cur >= 110 && cur < 120)
                    cerr << "";
                while (m <= r && x[m] - x[l] + c < x[r] - x[m])
                    ++m;
                while (m1 + 1 <= r && x[m1 + 1] - x[l] <= x[r] - x[m1 + 1] + c)
                    ++m1;
                if (max(pref[l] + suff[r] + x.back() - (x[r] - x[l]) + min(c, x[r] - x[l]), pathsuff[r]) <= cur)
                    if (m > r || r + 1 >= n || Max(t1, lazy1, 1, 0, n - 1, m, r) + x[r + 1] - x[r] + suff[r + 1] + (x.back() - x[r + 1]) <= cur)
                        if (l > m - 1 || r + 1 >= n || Max(t2, lazy2, 1, 0, n - 1, l, m - 1) + x[r + 1] - x[r] + suff[r + 1] + (x.back() - x[r + 1]) <= cur)
                            break;
                ++r;
                while (m <= r && x[m] - x[l] + c < x[r] - x[m])
                    ++m;
                while (m1 + 1 <= r && x[m1 + 1] - x[l] <= x[r] - x[m1 + 1] + c)
                    ++m1;
                if (l <= r - 1)
                {
                    Add(t1, lazy1, 1, 0, n - 1, l, r - 1, x[r] - x[r - 1]);
                    Add(t4, lazy4, 1, 0, n - 1, l, r - 1, x[r] - x[r - 1]);
                    if (false && cur == 110)
                    {
                        cerr << "Add(t1, lazy1, " << l << ", " << r - 1 << ", " << x[r] - x[r - 1] << ")\n";
                        for (int i = l; i <= r; ++i)
                            cerr << "tree1[" << i << "] = " << Max(t1, lazy1, 1, 0, n - 1, i, i) << '\n';
                        cerr << "-----------------\n";
                    }
                }
                Add(t2, lazy2, 1, 0, n - 1, r, r, x[r] - x[l]);
                Add(t3, lazy3, 1, 0, n - 1, r, r, x[r] - x[l]);
                if (false && cur == 100)
                {
                    for (int i = l; i <= m1; ++i)
                        cerr << "tree3[" << i << "] = " << Max(t3, lazy3, 1, 0, n - 1, i, i) << '\n';
                    cerr << "------\n";
                }
            }
            if (r >= n)
                break;
            if (false && cur == 110 && l == 2)
            {
                for (int i = l; i <= m1; ++i)
                    cerr << "tree3[" << i << "] = " << Max(t3, lazy3, 1, 0, n - 1, i, i) << '\n';
                cerr << "";
            }
            if (l <= m1 && l && Max(t3, lazy3, 1, 0, n - 1, l, m1) + x[l] - x[l - 1] + pref[l - 1] + x[l - 1] > cur)
                continue;
            if (m1 + 1 <= r && l && Max(t4, lazy4, 1, 0, n - 1, m1 + 1, r) + x[l] - x[l - 1] + pref[l - 1] + x[l - 1] > cur)
                continue;
            if (Poss(l, r, cur))
            {
                poss = true;
                if (false && cur == 100)
                {
                    for (int i = l; i <= m1; ++i)
                        cerr << "tree3[" << i << "] = " << Max(t3, lazy3, 1, 0, n - 1, i, i) << '\n';
                    cerr << "";
                }
                break;
            }
            if (l <= r) Add(t2, lazy2, 1, 0, n - 1, l, r, -(x[l + 1] - x[l]));
            if (l <= r) Add(t3, lazy3, 1, 0, n - 1, l, r, -(x[l + 1] - x[l]));
        }
        if (poss)
        {
            ans = cur;
            ans_r = cur - 1;
        }
        else
            ans_l = cur + 1;
    }
    return ans;
}

• Subtask 1: 9 / 9
• Subtask 2: 14 / 14
• Subtask 3: 8 / 8
• Subtask 4: 0 / 7
• Subtask 5: 0 / 33
• Subtask 6: 0 / 22
• Subtask 7: 0 / 4
• Subtask 8: 0 / 3