제출 #162750

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
162750		rama_pang	Shortcut (IOI16_shortcut)	C++14	100 / 100	1855 ms	135228 KiB

shortcut

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

struct SumDif {
    lint sum, dif;
    lint X, D;
    int id;
};

int N, C;

SumDif SUM[1000000]; // increasing X[i] + D[i]
SumDif DIF[1000000]; // increasing X[i] - D[i]
SumDif GEN[1000000]; // general information

inline bool is_valid(lint &T) {
    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
    int  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
    int  dif_idx = -1;   // index of dif_sml

    for (int j = 0, pos = 0; j < N; j++) {
        while (pos < N && SUM[j].sum - DIF[pos].dif > T) {
            lint sum_val = DIF[pos].sum;
            lint dif_val = DIF[pos].dif;

            if (sum_big < sum_val) {
                sum_sml = sum_big;
                sum_big = sum_val;
                sum_idx = DIF[pos].id;
            } else if (sum_sml < sum_val) {
                sum_sml = sum_val;
            }

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

            pos++;
        }

        lint valid_sum = ((SUM[j].id != sum_idx)? sum_big : sum_sml);
        lint valid_dif = ((SUM[j].id != dif_idx)? dif_sml : dif_big);
        lint sum_val = SUM[j].sum;
        lint dif_val = SUM[j].dif;

        max_sum = min(max_sum, + T + valid_dif + dif_val - C);        
        min_sum = max(min_sum, - T + valid_sum + sum_val + C);
        max_dif = min(max_dif, + T + valid_dif - sum_val - C);
        min_dif = max(min_dif, - T + valid_sum - dif_val + C);
    }

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

    }

    return false;
}

lint find_shortcut(int n_, vector<int> l_, vector<int> d_, int c_) {
    N = n_, C = c_;

    for (int i = 0; i < l_.size(); i++)
        GEN[i + 1].X = GEN[i].X + l_[i];
    for (int i = 0; i < d_.size(); i++)
        GEN[i].D = d_[i];
    for (int i = 0; i < N; i++) {
        SUM[i] = SumDif{GEN[i].X + GEN[i].D, GEN[i].X - GEN[i].D, GEN[i].X, GEN[i].D, i};
        DIF[i] = SumDif{GEN[i].X + GEN[i].D, GEN[i].X - GEN[i].D, GEN[i].X, GEN[i].D, i};
    }

    sort(SUM, SUM + N, [&] (SumDif &l, SumDif &r) { return l.sum < r.sum; });
    sort(DIF, DIF + N, [&] (SumDif &l, SumDif &r) { return l.dif < r.dif; });

    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;
}

컴파일 시 표준 에러 (stderr) 메시지

shortcut.cpp: In function 'lint find_shortcut(int, std::vector<int>, std::vector<int>, int)':
shortcut.cpp:88:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
     for (int i = 0; i < l_.size(); i++)
                     ~~^~~~~~~~~~~
shortcut.cpp:90: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: 3 / 3