Submission #62122

#	Time	Username	Problem	Language	Result	Execution time	Memory
62122		fallingstar	Shortcut (IOI16_shortcut)	C++14	0 / 100	4 ms	668 KiB

shortcut

#include "shortcut.h"
#include <algorithm>

#define long long long

using namespace std;

const int N = 1e6 + 2;
const int LN = 20;
const long INF = 1LL << 60;

int n, sec[N];
long dmain[N], express;
int rmqp[LN][N], rmqs[LN][N];

void BuildRMQ()
{
    for (int i = 0; i < n; ++i)
        rmqp[0][i] = rmqs[0][i] = i;

    for (int j = 1; j < LN; ++j)
        for (int i = 0; i + (1 << j) <= n; ++i)
        {
            rmqp[j][i] = max(rmqp[j - 1][i], rmqp[j - 1][i + (1 << (j - 1))], [](int x, int y) {
                return dmain[x] + sec[x] < dmain[y] + sec[y];
            });
            rmqs[j][i] = max(rmqs[j - 1][i], rmqs[j - 1][i + (1 << (j - 1))], [](int x, int y) {
                return -dmain[x] + sec[x] < -dmain[y] + sec[y];
            });
        }
}

int QueryPref(int l, int r)
{
    int k = 31 - __builtin_clz(r - l + 1);
    return max(rmqp[k][l], rmqp[k][r - (1 << k) + 1], [](int x, int y) {
                return dmain[x] + sec[x] < dmain[y] + sec[y];
            });
}
int QuerySuff(int l, int r)
{
    int k = 31 - __builtin_clz(r - l + 1);
    return max(rmqs[k][l], rmqs[k][r - (1 << k) + 1], [](int x, int y) {
                return -dmain[x] + sec[x] < -dmain[y] + sec[y];
            });
}
long GetPref(int l, int r)
{
    if (l > r) return -INF;
    int u = QueryPref(l, r);
    return dmain[u] + sec[u];
}
long GetSuff(int l, int r)
{
    if (l > r) return -INF;
    int u = QuerySuff(l, r);
    return dmain[n - 1] - dmain[u] + sec[u];
}

void Prep()
{
    BuildRMQ();
}

void Maximize(long &a, long b) { a = max(a, b); }
long Dist(int u, int v) { return abs(dmain[v] - dmain[u]); }

long dL[N], dR[N];

long GetAns(int u, int v)
{
    if (u > v) swap(u, v);

    long ans = 0;
    for (int i = 0, midR = u; i < n; ++i)
    {
        long &distR = dR[i];
        distR = 0;

        if (i < v)
        {
            while (midR < v && Dist(i, midR + 1) < Dist(midR + 1, v) + express + Dist(u, i)) ++midR;
            Maximize(distR, GetPref(v, n - 1) - dmain[v] + min(express + Dist(u, i), Dist(v, i)));
            Maximize(distR, GetSuff(midR + 1, v) - Dist(n - 1, v) + express + Dist(u, i));
            Maximize(distR, GetPref(i + 1, midR) - dmain[i]);
        }
        else
            Maximize(distR, GetPref(i + 1, n - 1) - dmain[i]);
    }

    for (int i = n - 1, midL = v; i >= 0; --i)
    {
        long distL = 0, distR = dR[i];
        if (i > u)
        {
            while (midL > u && Dist(midL - 1, i) < Dist(midL - 1, u) + express + Dist(v, i)) --midL;
            Maximize(distL, GetSuff(0, u) - Dist(u, n - 1) + min(express + Dist(i, v), Dist(u, i)));
            Maximize(distL, GetPref(u, midL - 1) - dmain[u] + express + Dist(v, i));
            Maximize(distL, GetSuff(midL, i) - Dist(i, n - 1));
        }
        else
            Maximize(distL, GetSuff(0, i - 1) - Dist(i, n - 1));

        ans = max(ans, sec[i] + max(distL, distR));
    }
    return ans;
}

long find_shortcut(int n_, vector<int> a_, vector<int> d_, int c_)
{
    n = n_, express = c_;
    for (int i = 1; i < n; ++i)
        dmain[i] = dmain[i - 1] + a_[i - 1];
    copy(d_.begin(), d_.end(), sec);
    Prep();

    long cur = 0, res = INF;
//    for (int l = 0, r = 0; l < n; ++l)
//    {
//        if (r <= l) r = l + 1, cur = GetAns(l, r);
//        long new_val = 0;
//        while (r < n)
//        {
//            new_val = GetAns(l, r + 1);
//            if (new_val <= cur) cur = new_val, ++r;
//            else break;
//        }
//        res = min(res, cur);
//    }
    for (int i = 0; i < n; ++i)
        for (int j = i + 1; j < n; ++j)
            res = min(res, GetAns(i, j));
    return res;
}

Compilation message (stderr)

shortcut.cpp: In function 'long long int find_shortcut(int, std::vector<int>, std::vector<int>, int)':
shortcut.cpp:117:10: warning: unused variable 'cur' [-Wunused-variable]
     long cur = 0, res = INF;
          ^~~

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