#827359 (C++17) No.2169 To Arithmetic

• 問題: No.2169 To Arithmetic
• ユーザー: suisen
• 提出日時: 2022-12-21 00:41:03
• 言語: C++17 (gcc 12.3.0 + boost 1.83.0)
• 結果: AC
• 実行時間: 139 ms / 2,000 ms
• コード長: 21,019 bytes
• コンパイル時間: 3,102 ms
• コンパイル使用メモリ: 322,324 KB
• 実行使用メモリ: 11,324 KB
• 最終ジャッジ日時: 2024-04-29 03:05:07
• 合計ジャッジ時間: 7,552 ms
• ジャッジサーバーID （参考情報）: judge3 / judge5

入力	結果	実行時間; 実行使用メモリ
testcase_00	AC	2 ms; 5,248 KB
testcase_01	AC	2 ms; 5,376 KB
testcase_02	AC	2 ms; 5,376 KB
testcase_03	AC	2 ms; 5,376 KB
testcase_04	AC	3 ms; 5,376 KB
testcase_05	AC	3 ms; 5,376 KB
testcase_06	AC	3 ms; 5,376 KB
testcase_07	AC	3 ms; 5,376 KB
testcase_08	AC	2 ms; 5,376 KB
testcase_09	AC	31 ms; 5,376 KB
testcase_10	AC	61 ms; 7,344 KB
testcase_11	AC	58 ms; 7,448 KB
testcase_12	AC	40 ms; 6,656 KB
testcase_13	AC	79 ms; 8,320 KB
testcase_14	AC	41 ms; 5,980 KB
testcase_15	AC	43 ms; 6,976 KB
testcase_16	AC	41 ms; 6,044 KB
testcase_17	AC	71 ms; 8,632 KB
testcase_18	AC	37 ms; 5,968 KB
testcase_19	AC	113 ms; 11,192 KB
testcase_20	AC	112 ms; 11,324 KB
testcase_21	AC	117 ms; 11,324 KB
testcase_22	AC	139 ms; 11,200 KB
testcase_23	AC	113 ms; 11,192 KB
testcase_24	AC	88 ms; 11,200 KB
testcase_25	AC	76 ms; 9,440 KB
testcase_26	AC	91 ms; 11,192 KB
testcase_27	AC	94 ms; 11,196 KB

ソースコード

#include <bits/stdc++.h>

#ifdef _MSC_VER
#  include <intrin.h>
#else
#  include <x86intrin.h>
#endif

#include <limits>
#include <type_traits>

namespace suisen {
// ! utility
template <typename ...Types>
using constraints_t = std::enable_if_t<std::conjunction_v<Types...>, std::nullptr_t>;
template <bool cond_v, typename Then, typename OrElse>
constexpr decltype(auto) constexpr_if(Then&& then, OrElse&& or_else) {
    if constexpr (cond_v) {
        return std::forward<Then>(then);
    } else {
        return std::forward<OrElse>(or_else);
    }
}

// ! function
template <typename ReturnType, typename Callable, typename ...Args>
using is_same_as_invoke_result = std::is_same<std::invoke_result_t<Callable, Args...>, ReturnType>;
template <typename F, typename T>
using is_uni_op = is_same_as_invoke_result<T, F, T>;
template <typename F, typename T>
using is_bin_op = is_same_as_invoke_result<T, F, T, T>;

template <typename Comparator, typename T>
using is_comparator = std::is_same<std::invoke_result_t<Comparator, T, T>, bool>;

// ! integral
template <typename T, typename = constraints_t<std::is_integral<T>>>
constexpr int bit_num = std::numeric_limits<std::make_unsigned_t<T>>::digits;
template <typename T, unsigned int n>
struct is_nbit { static constexpr bool value = bit_num<T> == n; };
template <typename T, unsigned int n>
static constexpr bool is_nbit_v = is_nbit<T, n>::value;

// ?
template <typename T>
struct safely_multipliable {};
template <>
struct safely_multipliable<int> { using type = long long; };
template <>
struct safely_multipliable<long long> { using type = __int128_t; };
template <>
struct safely_multipliable<unsigned int> { using type = unsigned long long; };
template <>
struct safely_multipliable<unsigned long int> { using type = __uint128_t; };
template <>
struct safely_multipliable<unsigned long long> { using type = __uint128_t; };
template <>
struct safely_multipliable<float> { using type = float; };
template <>
struct safely_multipliable<double> { using type = double; };
template <>
struct safely_multipliable<long double> { using type = long double; };
template <typename T>
using safely_multipliable_t = typename safely_multipliable<T>::type;

template <typename T, typename = void>
struct rec_value_type {
    using type = T;
};
template <typename T>
struct rec_value_type<T, std::void_t<typename T::value_type>> {
    using type = typename rec_value_type<typename T::value_type>::type;
};
template <typename T>
using rec_value_type_t = typename rec_value_type<T>::type;

} // namespace suisen

// ! type aliases
using i128 = __int128_t;
using u128 = __uint128_t;

template <typename T>
using pq_greater = std::priority_queue<T, std::vector<T>, std::greater<T>>;

// ! macros (internal)
#define DETAIL_OVERLOAD2(_1,_2,name,...) name
#define DETAIL_OVERLOAD3(_1,_2,_3,name,...) name
#define DETAIL_OVERLOAD4(_1,_2,_3,_4,name,...) name

#define DETAIL_REP4(i,l,r,s)  for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l);i<(r);i+=(s))
#define DETAIL_REP3(i,l,r)    DETAIL_REP4(i,l,r,1)
#define DETAIL_REP2(i,n)      DETAIL_REP3(i,0,n)
#define DETAIL_REPINF3(i,l,s) for(std::remove_reference_t<std::remove_const_t<decltype(l)>>i=(l);;i+=(s))
#define DETAIL_REPINF2(i,l)   DETAIL_REPINF3(i,l,1)
#define DETAIL_REPINF1(i)     DETAIL_REPINF2(i,0)
#define DETAIL_RREP4(i,l,r,s) for(std::remove_reference_t<std::remove_const_t<decltype(r)>>i=(l)+fld((r)-(l)-1,s)*(s);i>=(l);i-=(s))
#define DETAIL_RREP3(i,l,r)   DETAIL_RREP4(i,l,r,1)
#define DETAIL_RREP2(i,n)     DETAIL_RREP3(i,0,n)

#define DETAIL_CAT_I(a, b) a##b
#define DETAIL_CAT(a, b) DETAIL_CAT_I(a, b)
#define DETAIL_UNIQVAR(tag) DETAIL_CAT(tag, __LINE__)

// ! macros
#define REP(...)    DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_REP4   , DETAIL_REP3   , DETAIL_REP2   )(__VA_ARGS__)
#define RREP(...)   DETAIL_OVERLOAD4(__VA_ARGS__, DETAIL_RREP4  , DETAIL_RREP3  , DETAIL_RREP2  )(__VA_ARGS__)
#define REPINF(...) DETAIL_OVERLOAD3(__VA_ARGS__, DETAIL_REPINF3, DETAIL_REPINF2, DETAIL_REPINF1)(__VA_ARGS__)

#define LOOP(n) for (std::remove_reference_t<std::remove_const_t<decltype(n)>> DETAIL_UNIQVAR(loop_variable) = n; DETAIL_UNIQVAR(loop_variable) --> 0;)

#define ALL(iterable) std::begin(iterable), std::end(iterable)
#define INPUT(type, ...) type __VA_ARGS__; read(__VA_ARGS__)

// ! debug

#ifdef LOCAL
#  define debug(...) debug_internal(#__VA_ARGS__, __VA_ARGS__)

template <class T, class... Args>
void debug_internal(const char* s, T&& first, Args&&... args) {
    constexpr const char* prefix = "[\033[32mDEBUG\033[m] ";
    constexpr const char* open_brakets = sizeof...(args) == 0 ? "" : "(";
    constexpr const char* close_brakets = sizeof...(args) == 0 ? "" : ")";
    std::cerr << prefix << open_brakets << s << close_brakets << ": " << open_brakets << std::forward<T>(first);
    ((std::cerr << ", " << std::forward<Args>(args)), ...);
    std::cerr << close_brakets << "\n";
}

#else
#  define debug(...) void(0)
#endif

// ! I/O utilities

// __int128_t
std::ostream& operator<<(std::ostream& dest, __int128_t value) {
    std::ostream::sentry s(dest);
    if (s) {
        __uint128_t tmp = value < 0 ? -value : value;
        char buffer[128];
        char* d = std::end(buffer);
        do {
            --d;
            *d = "0123456789"[tmp % 10];
            tmp /= 10;
        } while (tmp != 0);
        if (value < 0) {
            --d;
            *d = '-';
        }
        int len = std::end(buffer) - d;
        if (dest.rdbuf()->sputn(d, len) != len) {
            dest.setstate(std::ios_base::badbit);
        }
    }
    return dest;
}
// __uint128_t
std::ostream& operator<<(std::ostream& dest, __uint128_t value) {
    std::ostream::sentry s(dest);
    if (s) {
        char buffer[128];
        char* d = std::end(buffer);
        do {
            --d;
            *d = "0123456789"[value % 10];
            value /= 10;
        } while (value != 0);
        int len = std::end(buffer) - d;
        if (dest.rdbuf()->sputn(d, len) != len) {
            dest.setstate(std::ios_base::badbit);
        }
    }
    return dest;
}

// pair
template <typename T, typename U>
std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) {
    return out << a.first << ' ' << a.second;
}
// tuple
template <unsigned int N = 0, typename ...Args>
std::ostream& operator<<(std::ostream& out, const std::tuple<Args...>& a) {
    if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) return out;
    else {
        out << std::get<N>(a);
        if constexpr (N + 1 < std::tuple_size_v<std::tuple<Args...>>) out << ' ';
        return operator<<<N + 1>(out, a);
    }
}
// vector
template <typename T>
std::ostream& operator<<(std::ostream& out, const std::vector<T>& a) {
    for (auto it = a.begin(); it != a.end();) {
        out << *it;
        if (++it != a.end()) out << ' ';
    }
    return out;
}
// array
template <typename T, size_t N>
std::ostream& operator<<(std::ostream& out, const std::array<T, N>& a) {
    for (auto it = a.begin(); it != a.end();) {
        out << *it;
        if (++it != a.end()) out << ' ';
    }
    return out;
}
inline void print() { std::cout << '\n'; }
template <typename Head, typename... Tail>
inline void print(const Head& head, const Tail &...tails) {
    std::cout << head;
    if (sizeof...(tails)) std::cout << ' ';
    print(tails...);
}
template <typename Iterable>
auto print_all(const Iterable& v, std::string sep = " ", std::string end = "\n") -> decltype(std::cout << *v.begin(), void()) {
    for (auto it = v.begin(); it != v.end();) {
        std::cout << *it;
        if (++it != v.end()) std::cout << sep;
    }
    std::cout << end;
}

__int128_t stoi128(const std::string& s) {
    __int128_t ret = 0;
    for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';
    if (s[0] == '-') ret = -ret;
    return ret;
}
__uint128_t stou128(const std::string& s) {
    __uint128_t ret = 0;
    for (int i = 0; i < int(s.size()); i++) if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';
    return ret;
}
// __int128_t
std::istream& operator>>(std::istream& in, __int128_t& v) {
    std::string s;
    in >> s;
    v = stoi128(s);
    return in;
}
// __uint128_t
std::istream& operator>>(std::istream& in, __uint128_t& v) {
    std::string s;
    in >> s;
    v = stou128(s);
    return in;
}
// pair
template <typename T, typename U>
std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {
    return in >> a.first >> a.second;
}
// tuple
template <unsigned int N = 0, typename ...Args>
std::istream& operator>>(std::istream& in, std::tuple<Args...>& a) {
    if constexpr (N >= std::tuple_size_v<std::tuple<Args...>>) return in;
    else return operator>><N + 1>(in >> std::get<N>(a), a);
}
// vector
template <typename T>
std::istream& operator>>(std::istream& in, std::vector<T>& a) {
    for (auto it = a.begin(); it != a.end(); ++it) in >> *it;
    return in;
}
// array
template <typename T, size_t N>
std::istream& operator>>(std::istream& in, std::array<T, N>& a) {
    for (auto it = a.begin(); it != a.end(); ++it) in >> *it;
    return in;
}
template <typename ...Args>
void read(Args &...args) {
    (std::cin >> ... >> args);
}

// ! integral utilities

// Returns pow(-1, n)
template <typename T> constexpr inline int pow_m1(T n) {
    return -(n & 1) | 1;
}
// Returns pow(-1, n)
template <> constexpr inline int pow_m1<bool>(bool n) {
    return -int(n) | 1;
}

// Returns floor(x / y)
template <typename T> constexpr inline T fld(const T x, const T y) {
    return (x ^ y) >= 0 ? x / y : (x - (y + pow_m1(y >= 0))) / y;
}
template <typename T> constexpr inline T cld(const T x, const T y) {
    return (x ^ y) <= 0 ? x / y : (x + (y + pow_m1(y >= 0))) / y;
}

template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>
__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u32(x); }
template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>
__attribute__((target("popcnt"))) constexpr inline int popcount(const T x) { return _mm_popcnt_u64(x); }
template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>
constexpr inline int count_lz(const T x) { return x ? __builtin_clz(x) : suisen::bit_num<T>; }
template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>
constexpr inline int count_lz(const T x) { return x ? __builtin_clzll(x) : suisen::bit_num<T>; }
template <typename T, std::enable_if_t<std::negation_v<suisen::is_nbit<T, 64>>, std::nullptr_t> = nullptr>
constexpr inline int count_tz(const T x) { return x ? __builtin_ctz(x) : suisen::bit_num<T>; }
template <typename T, std::enable_if_t<suisen::is_nbit_v<T, 64>, std::nullptr_t> = nullptr>
constexpr inline int count_tz(const T x) { return x ? __builtin_ctzll(x) : suisen::bit_num<T>; }
template <typename T> constexpr inline int floor_log2(const T x) { return suisen::bit_num<T> - 1 - count_lz(x); }
template <typename T> constexpr inline int ceil_log2(const T x) { return floor_log2(x) + ((x & -x) != x); }
template <typename T> constexpr inline int kth_bit(const T x, const unsigned int k) { return (x >> k) & 1; }
template <typename T> constexpr inline int parity(const T x) { return popcount(x) & 1; }

// ! container

template <typename T, typename Comparator>
auto priqueue_comp(const Comparator comparator) {
    return std::priority_queue<T, std::vector<T>, Comparator>(comparator);
}

template <typename Container>
void sort_unique_erase(Container& a) {
    std::sort(a.begin(), a.end());
    a.erase(std::unique(a.begin(), a.end()), a.end());
}

template <typename InputIterator, typename BiConsumer>
auto foreach_adjacent_values(InputIterator first, InputIterator last, BiConsumer f) -> decltype(f(*first++, *last), void()) {
    if (first != last) for (auto itr = first, itl = itr++; itr != last; itl = itr++) f(*itl, *itr);
}
template <typename Container, typename BiConsumer>
auto foreach_adjacent_values(Container &&c, BiConsumer f) -> decltype(c.begin(), c.end(), void()) {
    foreach_adjacent_values(c.begin(), c.end(), f);
}

// ! other utilities

// x <- min(x, y). returns true iff `x` has chenged.
template <typename T>
inline bool chmin(T& x, const T& y) {
    return y >= x ? false : (x = y, true);
}
// x <- max(x, y). returns true iff `x` has chenged.
template <typename T>
inline bool chmax(T& x, const T& y) {
    return y <= x ? false : (x = y, true);
}

template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>
std::string bin(T val, int bit_num = -1) {
    std::string res;
    if (bit_num != -1) {
        for (int bit = bit_num; bit-- > 0;) res += '0' + ((val >> bit) & 1);
    } else {
        for (; val; val >>= 1) res += '0' + (val & 1);
        std::reverse(res.begin(), res.end());
    }
    return res;
}

template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>
std::vector<T> digits_low_to_high(T val, T base = 10) {
    std::vector<T> res;
    for (; val; val /= base) res.push_back(val % base);
    if (res.empty()) res.push_back(T{ 0 });
    return res;
}
template <typename T, std::enable_if_t<std::is_integral_v<T>, std::nullptr_t> = nullptr>
std::vector<T> digits_high_to_low(T val, T base = 10) {
    auto res = digits_low_to_high(val, base);
    std::reverse(res.begin(), res.end());
    return res;
}

template <typename T>
std::string join(const std::vector<T>& v, const std::string& sep, const std::string& end) {
    std::ostringstream ss;
    for (auto it = v.begin(); it != v.end();) {
        ss << *it;
        if (++it != v.end()) ss << sep;
    }
    ss << end;
    return ss.str();
}

namespace suisen {}
using namespace suisen;
using namespace std;

struct io_setup {
    io_setup(int precision = 20) {
        std::ios::sync_with_stdio(false);
        std::cin.tie(nullptr);
        std::cout << std::fixed << std::setprecision(precision);
    }
} io_setup_{};

// ! code from here

#include <cassert>
#include <queue>

namespace suisen {
    namespace internal::monotonic_cht { struct query_tag_base {}; }
    struct inc_query_tag : internal::monotonic_cht::query_tag_base {};
    struct dec_query_tag : internal::monotonic_cht::query_tag_base {};
    struct non_monotonic_query_tag : internal::monotonic_cht::query_tag_base {};

    template <typename T, bool is_min_query, typename QueryTag,
        std::enable_if_t<std::is_base_of_v<internal::monotonic_cht::query_tag_base, QueryTag>, std::nullptr_t> = nullptr
    >
    struct MonotonicCHT {
        using value_type = T;
        using query_tag = QueryTag;

        MonotonicCHT() = default;
    private:
        template <typename, typename = void>
        struct query_impl {};
        template <typename Dummy>
        struct query_impl<inc_query_tag, Dummy> {
            value_type prev_x = std::numeric_limits<value_type>::min();
            value_type operator()(MonotonicCHT* ptr, value_type x) {
                assert(x >= prev_x);
                prev_x = x;
                assert(ptr->lines.size());
                value_type res = ptr->eval(x, 0);
                while (ptr->lines.size() >= 2) {
                    value_type nxt_res = ptr->eval(x, 1);
                    if (res < nxt_res) break;
                    ptr->lines.pop_front();
                    std::swap(res, nxt_res);
                }
                return res;
            }
        };
        template <typename Dummy>
        struct query_impl<dec_query_tag, Dummy> {
            value_type prev_x = std::numeric_limits<value_type>::max();
            value_type operator()(MonotonicCHT* ptr, value_type x) {
                assert(x <= prev_x);
                prev_x = x;
                assert(ptr->lines.size());
                value_type res = ptr->eval(x, ptr->lines.size() - 1);
                while (ptr->lines.size() >= 2) {
                    value_type nxt_res = ptr->eval(x, ptr->lines.size() - 2);
                    if (res < nxt_res) break;
                    ptr->lines.pop_back();
                    std::swap(res, nxt_res);
                }
                return res;
            }
        };
        template <typename Dummy>
        struct query_impl<non_monotonic_query_tag, Dummy> {
            value_type operator()(MonotonicCHT* ptr, value_type x) {
                assert(ptr->lines.size());
                int l = -1, r = ptr->lines.size();
                while (r - l >= 3) {
                    int ml = l + (r - l) / 3;
                    int mr = r - (r - l) / 3;
                    if (ptr->eval(x, ml) < ptr->eval(x, mr)) {
                        r = mr;
                    } else {
                        l = ml;
                    }
                }
                assert(r - l == 2);
                return ptr->eval(x, l + 1);
            }
        };
    public:
        void add_line(value_type slope, value_type intercept) {
            if constexpr (not is_min_query) slope = -slope, intercept = -intercept;
            if (slope <= min_slope) {
                min_slope = slope, max_slope = std::max(max_slope, slope);
                add_right(slope, intercept);
            } else if (slope >= max_slope) {
                max_slope = slope, min_slope = std::min(min_slope, slope);
                add_left(slope, intercept);
            } else assert(false);
        }

        value_type query(value_type x) {
            return (is_min_query ? 1 : -1) * _query(this, x);
        }
    private:
        std::deque<std::pair<value_type, value_type>> lines;
        value_type max_slope = std::numeric_limits<value_type>::min();
        value_type min_slope = std::numeric_limits<value_type>::max();
        query_impl<query_tag> _query{};

        // check if ma * x + mb is necessary.
        bool is_necessary(value_type la, value_type lb, value_type ma, value_type mb, value_type ra, value_type rb) {
            using MultT = std::conditional_t<std::is_integral_v<value_type>, __int128_t, value_type>;
            return MultT(lb - mb) * (ra - ma) > MultT(mb - rb) * (ma - la);
        }

        void add_left(value_type slope, value_type intercept) {
            while (lines.size()) {
                auto it = lines.begin();
                const auto [a, b] = *it;
                if (a == slope) {
                    if (intercept >= b) return;
                } else {
                    if (++it == lines.end() or is_necessary(it->first, it->second, a, b, slope, intercept)) break;
                }
                lines.pop_front();
            }
            lines.emplace_front(slope, intercept);
        }

        void add_right(value_type slope, value_type intercept) {
            while (lines.size()) {
                auto it = lines.rbegin();
                const auto [a, b] = *it;
                if (a == slope) {
                    if (intercept >= b) return;
                } else {
                    if (++it == lines.rend() or is_necessary(slope, intercept, a, b, it->first, it->second)) break;
                }
                lines.pop_back();
            }
            lines.emplace_back(slope, intercept);
        }

        value_type eval(value_type x, int i) {
            const auto& [a, b] = lines[i];
            return a * x + b;
        }
    };

    template <typename T, typename QueryTag>
    using MinMonotonicCHT = MonotonicCHT<T, true, QueryTag>;
    template <typename T, typename QueryTag>
    using MaxMonotonicCHT = MonotonicCHT<T, false, QueryTag>;
} // namespace suisen

int main() {
    int n, q;
    read(n, q);
    vector<long long> a(n);
    read(a);

    MaxMonotonicCHT<long long, inc_query_tag> cht;
    REP(i, n) {
        cht.add_line(-i, a[i]);
    }

    vector<pair<long long, int>> ds(q);
    REP(i, q) {
        read(ds[i].first);
        ds[i].second = i;
    }
    sort(ALL(ds));

    long long difsum = 0;

    priority_queue<long long> pq;
    REP(i, 1, n) {
        long long dif = a[i - 1] - a[i] + ds[0].first;
        difsum += abs(dif);
        if (dif < 0) pq.emplace(dif);
    }
    long long pd = ds[0].first;

    vector<long long> ans(q);
    for (auto [d, qid] : ds) {
        long long t = cht.query(d);

        REP(i, n) {
            debug(a[i], t + i * d);
        }

        long long dd = d - pd;
        difsum += dd * (n - 1 - int(pq.size())); // positive

        while (pq.size()) {
            long long tp = pq.top();
            if (tp < -(d - ds[0].first)) break;
            pq.pop();
            long long cur = abs(tp + pd - ds[0].first);
            long long nxt = abs(tp + d - ds[0].first);
            difsum += nxt - cur;
        }
        difsum -= dd * int(pq.size());

        long long d0 = t - a.front();
        long long dn = t + (n - 1) * d - a.back();

        debug(difsum, d0, dn);

        ans[qid] = (difsum + d0 + dn) / 2;

        pd = d;
    }
    print_all(ans, "\n");

    return 0;
}