結果
問題 | No.2169 To Arithmetic |
ユーザー |
|
提出日時 | 2022-12-21 00:41:03 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 125 ms / 2,000 ms |
コード長 | 21,019 bytes |
コンパイル時間 | 2,997 ms |
コンパイル使用メモリ | 324,112 KB |
最終ジャッジ日時 | 2025-02-09 17:45:08 |
ジャッジサーバーID (参考情報) |
judge5 / judge3 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
sample | AC * 3 |
other | AC * 25 |
ソースコード
#include <bits/stdc++.h>#ifdef _MSC_VER# include <intrin.h>#else# include <x86intrin.h>#endif#include <limits>#include <type_traits>namespace suisen {// ! utilitytemplate <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);}}// ! functiontemplate <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>;// ! integraltemplate <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 aliasesusing 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_tstd::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_tstd::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;}// pairtemplate <typename T, typename U>std::ostream& operator<<(std::ostream& out, const std::pair<T, U>& a) {return out << a.first << ' ' << a.second;}// tupletemplate <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);}}// vectortemplate <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;}// arraytemplate <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_tstd::istream& operator>>(std::istream& in, __int128_t& v) {std::string s;in >> s;v = stoi128(s);return in;}// __uint128_tstd::istream& operator>>(std::istream& in, __uint128_t& v) {std::string s;in >> s;v = stou128(s);return in;}// pairtemplate <typename T, typename U>std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {return in >> a.first >> a.second;}// tupletemplate <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);}// vectortemplate <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;}// arraytemplate <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; }// ! containertemplate <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 suisenint 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())); // positivewhile (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;}