Submission #162733

#	Time	Username	Problem	Language	Result	Execution time	Memory
162733		rama_pang	Shortcut (IOI16_shortcut)	C++14	97 / 100	2060 ms	55288 KiB

shortcut

#include "shortcut.h"
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint INF = 2e15;

int N, C;
vector<lint> X;
vector<lint> D;
vector<int> SUM; // index of increasing X[i] + D[i]
vector<int> DIF; // index of increasing X[i] - D[i]

vector<lint> SUM_VAL; // stores X[i] + D[i]
vector<lint> DIF_VAL; // stores X[i] - D[i]

lint max_sum = +INF; // maximum of S1 + S2 that is valid
lint min_sum = -INF; // minimum of S1 + S2 that is valid
lint max_dif = +INF; // maximum of S1 - S2 that is valid
lint min_dif = -INF; // minimum of S1 - S2 that is valid
lint sum_big = -INF; // maximum X[i] + D[i], for all valid i
lint sum_sml = -INF; // second maximum X[i] + D[i], for all valid i
lint sum_idx = -1;   // index of sum_big
lint dif_sml = +INF; // minimum X[i] - D[i], for all valid i
lint dif_big = +INF; // second minimum X[i] - D[i], for all valid i
lint dif_idx = -1;   // index of dif_sml
lint valid_sum;
lint valid_dif;

bool is_valid(lint T) {
    max_sum = +INF; // maximum of S1 + S2 that is valid
    min_sum = -INF; // minimum of S1 + S2 that is valid
    max_dif = +INF; // maximum of S1 - S2 that is valid
    min_dif = -INF; // minimum of S1 - S2 that is valid
    sum_big = -INF; // maximum X[i] + D[i], for all valid i
    sum_sml = -INF; // second maximum X[i] + D[i], for all valid i
    sum_idx = -1;   // index of sum_big
    dif_sml = +INF; // minimum X[i] - D[i], for all valid i
    dif_big = +INF; // second minimum X[i] - D[i], for all valid i
    dif_idx = -1;   // index of dif_sml

    for (int j = 0, pos = 0; j < N; j++) {
        while (pos < N && SUM_VAL[SUM[j]] - DIF_VAL[DIF[pos]] > T) {
            if (sum_big < SUM_VAL[DIF[pos]]) {
                sum_sml = sum_big;
                sum_big = SUM_VAL[DIF[pos]];
                sum_idx = DIF[pos];
            } else if (sum_sml < SUM_VAL[DIF[pos]]) {
                sum_sml = SUM_VAL[DIF[pos]];
            }

            if (dif_sml > DIF_VAL[DIF[pos]]) {
                dif_big = dif_sml;
                dif_sml = DIF_VAL[DIF[pos]];
                dif_idx = DIF[pos];
            } else if (dif_big > DIF_VAL[DIF[pos]]) {
                dif_big = DIF_VAL[DIF[pos]];
            }

            pos++;
        }

        valid_sum = ((SUM[j] == sum_idx)? sum_sml : sum_big);
        valid_dif = ((SUM[j] == dif_idx)? dif_big : dif_sml);

        max_sum = min(max_sum, + T + valid_dif + DIF_VAL[SUM[j]] - C);        
        min_sum = max(min_sum, - T + valid_sum + SUM_VAL[SUM[j]] + C);
        max_dif = min(max_dif, + T + valid_dif - SUM_VAL[SUM[j]] - C);
        min_dif = max(min_dif, - T + valid_sum - DIF_VAL[SUM[j]] + C);
    }

    for (int i = 0, ptl = 0, ptr = N - 1, pos; i < N; i++) {
        while (ptl <  N && X[ptl] - X[i] <  min_dif) ptl++;
        while (ptr >= 0 && X[ptr] + X[i] >= min_sum) ptr--;
        
        pos = max(ptl, ptr + 1);
        if (pos < N && min_sum <= X[pos] + X[i] && X[pos] + X[i] <= max_sum 
                    && min_dif <= X[pos] - X[i] && X[pos] - X[i] <= max_dif)
            return true;

    }

    return false;
}

lint find_shortcut(int n_, vector<int> l_, vector<int> d_, int c_) {
    N = n_, C = c_;
    X.reserve(N), D.reserve(N);
    SUM.reserve(N), DIF.reserve(N);
    SUM_VAL.reserve(N), DIF_VAL.reserve(N);
    X.resize(N), D.resize(N);
    SUM.resize(N), DIF.resize(N);
    SUM_VAL.resize(N), DIF_VAL.resize(N);

    for (int i = 0; i < l_.size(); i++)
        X[i + 1] = X[i] + l_[i];
    for (int i = 0; i < d_.size(); i++)
        D[i] = d_[i];
    for (int i = 0; i < N; i++) {
        SUM_VAL[i] = X[i] + D[i];
        DIF_VAL[i] = X[i] - D[i];
    }

    iota(SUM.begin(), SUM.end(), 0), iota(DIF.begin(), DIF.end(), 0);
    sort(SUM.begin(), SUM.end(), [&] (int l, int r) { return SUM_VAL[l] < SUM_VAL[r]; });
    sort(DIF.begin(), DIF.end(), [&] (int l, int r) { return DIF_VAL[l] < DIF_VAL[r]; });

    lint res = 0;
    
    for (lint L = 0, R = INF, M = (L + R) / 2; L <= R; M = (L + R) / 2) 
        if (is_valid(M))
            R = M - 1, res = M;
        else
            L = M + 1;
    
    return res;
}

Compilation message (stderr)

shortcut.cpp: In function 'lint find_shortcut(int, std::vector<int>, std::vector<int>, int)':
shortcut.cpp:94:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for (int i = 0; i < l_.size(); i++)
                     ~~^~~~~~~~~~~
shortcut.cpp:96:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for (int i = 0; i < d_.size(); i++)
                     ~~^~~~~~~~~~~

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