#323930 (C++17) No.409 ダイエット

提出ソース

結果

問題	No.409 ダイエット
ユーザー	Pachicobue
提出日時	2019-03-16 11:50:17
言語	C++17 (gcc 13.2.0 + boost 1.83.0)
結果	AC
実行時間	96 ms / 2,000 ms
コード長	11,358 bytes
コンパイル時間	2,064 ms
コンパイル使用メモリ	206,360 KB
実行使用メモリ	13,228 KB
最終ジャッジ日時	2023-09-14 15:11:00
合計ジャッジ時間	7,404 ms
ジャッジサーバーID （参考情報）	judge11 / judge14

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 4,376 KB
testcase_01	AC	2 ms 4,380 KB
testcase_02	AC	1 ms 4,380 KB
testcase_03	AC	2 ms 4,376 KB
testcase_04	AC	2 ms 4,380 KB
testcase_05	AC	2 ms 4,380 KB
testcase_06	AC	2 ms 4,380 KB
testcase_07	AC	2 ms 4,376 KB
testcase_08	AC	2 ms 4,376 KB
testcase_09	AC	1 ms 4,376 KB
testcase_10	AC	2 ms 4,376 KB
testcase_11	AC	2 ms 4,380 KB
testcase_12	AC	2 ms 4,380 KB
testcase_13	AC	2 ms 4,376 KB
testcase_14	AC	2 ms 4,380 KB
testcase_15	AC	2 ms 4,376 KB
testcase_16	AC	2 ms 4,376 KB
testcase_17	AC	2 ms 4,376 KB
testcase_18	AC	2 ms 4,380 KB
testcase_19	AC	2 ms 4,376 KB
testcase_20	AC	2 ms 4,376 KB
testcase_21	AC	2 ms 4,380 KB
testcase_22	AC	2 ms 4,376 KB
testcase_23	AC	1 ms 4,380 KB
testcase_24	AC	2 ms 4,376 KB
testcase_25	AC	2 ms 4,376 KB
testcase_26	AC	2 ms 4,376 KB
testcase_27	AC	2 ms 4,380 KB
testcase_28	AC	1 ms 4,376 KB
testcase_29	AC	2 ms 4,376 KB
testcase_30	AC	2 ms 4,376 KB
testcase_31	AC	1 ms 4,380 KB
testcase_32	AC	2 ms 4,376 KB
testcase_33	AC	2 ms 4,380 KB
testcase_34	AC	1 ms 4,380 KB
testcase_35	AC	3 ms 4,376 KB
testcase_36	AC	2 ms 4,380 KB
testcase_37	AC	3 ms 4,380 KB
testcase_38	AC	2 ms 4,380 KB
testcase_39	AC	3 ms 4,376 KB
testcase_40	AC	3 ms 4,376 KB
testcase_41	AC	3 ms 4,376 KB
testcase_42	AC	3 ms 4,376 KB
testcase_43	AC	3 ms 4,380 KB
testcase_44	AC	2 ms 4,376 KB
testcase_45	AC	3 ms 4,376 KB
testcase_46	AC	3 ms 4,380 KB
testcase_47	AC	3 ms 4,376 KB
testcase_48	AC	3 ms 4,376 KB
testcase_49	AC	3 ms 4,376 KB
testcase_50	AC	3 ms 4,384 KB
testcase_51	AC	3 ms 4,380 KB
testcase_52	AC	3 ms 4,380 KB
testcase_53	AC	3 ms 4,376 KB
testcase_54	AC	3 ms 4,380 KB
testcase_55	AC	31 ms 7,400 KB
testcase_56	AC	54 ms 7,484 KB
testcase_57	AC	61 ms 13,060 KB
testcase_58	AC	28 ms 7,000 KB
testcase_59	AC	39 ms 7,804 KB
testcase_60	AC	25 ms 7,116 KB
testcase_61	AC	55 ms 11,376 KB
testcase_62	AC	58 ms 12,216 KB
testcase_63	AC	55 ms 11,376 KB
testcase_64	AC	30 ms 7,112 KB
testcase_65	AC	56 ms 9,264 KB
testcase_66	AC	61 ms 13,124 KB
testcase_67	AC	47 ms 11,016 KB
testcase_68	AC	38 ms 7,876 KB
testcase_69	AC	53 ms 12,556 KB
testcase_70	AC	78 ms 12,140 KB
testcase_71	AC	45 ms 7,076 KB
testcase_72	AC	96 ms 11,788 KB
testcase_73	AC	88 ms 12,036 KB
testcase_74	AC	57 ms 11,000 KB
testcase_75	AC	89 ms 13,228 KB
testcase_76	AC	66 ms 11,556 KB
testcase_77	AC	43 ms 6,076 KB
testcase_78	AC	51 ms 9,952 KB
testcase_79	AC	40 ms 6,952 KB
testcase_80	AC	91 ms 11,868 KB
testcase_81	AC	88 ms 12,544 KB
testcase_82	AC	66 ms 10,976 KB
testcase_83	AC	71 ms 11,500 KB
testcase_84	AC	58 ms 7,804 KB
testcase_85	AC	8 ms 4,376 KB
testcase_86	AC	56 ms 7,712 KB
testcase_87	AC	79 ms 11,296 KB
testcase_88	AC	33 ms 5,512 KB
testcase_89	AC	65 ms 6,780 KB
testcase_90	AC	31 ms 4,968 KB
testcase_91	AC	69 ms 6,964 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wsign-conversion"
//!===========================================================!//
//!  dP     dP                          dP                    !//
//!  88     88                          88                    !//
//!  88aaaaa88a .d8888b. .d8888b. .d888b88 .d8888b. 88d888b.  !//
//!  88     88  88ooood8 88'  '88 88'  '88 88ooood8 88'  '88  !//
//!  88     88  88.  ... 88.  .88 88.  .88 88.  ... 88        !//
//!  dP     dP  '88888P' '88888P8 '88888P8 '88888P' dP        !//
//!===========================================================!//
using ld = long double;
using ll = long long;
using ull = unsigned long long;
std::mt19937 mt{std::random_device{}()};
template <typename T>
constexpr T INF = std::numeric_limits<T>::max() / 4;
template <typename T>
constexpr T MOD = static_cast<T>(1000000007);
template <typename F>
constexpr F PI() { return 3.1415926535897932385; }
#define SHOW(...) (std::cerr << "(" << #__VA_ARGS__ << ") = ("), HogeHogeSansuu(__VA_ARGS__), std::cerr << ")" << std::endl;
struct has_debugPrint_impl
{
    template <class T>
    static auto check(T&& x) -> decltype(x.debugPrint(), std::true_type{});
    template <class T>
    static auto check(...) -> std::false_type;
};
template <class T>
class has_debugPrint : public decltype(has_debugPrint_impl::check<T>(std::declval<T>()))
{
};
template <bool>
struct HogeHogeDump
{
    template <typename T>
    static void dump(const T& x) { x.debugPrint(); }
};
template <>
struct HogeHogeDump<false>
{
    template <typename T>
    static void dump(const T& x) { std::cerr << x; }
};
void HogeHogeSansuu() { ; }
template <typename T>
void HogeHogeSansuu(const T& x) { HogeHogeDump<has_debugPrint<T>::value>::dump(x); }
template <typename T, typename... Args>
void HogeHogeSansuu(const T& x, Args... args) { HogeHogeDump<has_debugPrint<T>::value>::dump(x), std::cerr << ",", HogeHogeSansuu(args...); }
template <typename T>
bool chmin(T& a, const T& b) { return a = std::min(a, b), a == b; }
template <typename T>
bool chmax(T& a, const T& b) { return a = std::max(a, b), a == b; }
template <typename T, typename F>
void For(const T s, const T t, const F f)
{
    for (T i = s; i != t; i += T(s < t ? 1 : -1)) { f(i); }
}
template <typename T, typename F>
void Rep(const T N, const F f) { For<T, F>(0, N, f); }
template <typename T, typename F>
void RRep(const T N, const F f) { For<T, F>(N - 1, -1, f); }
template <typename T>
std::vector<T> Vec(const std::size_t n, T v) { return std::vector<T>(n, v); }
template <class... Args>
auto Vec(const std::size_t n, Args... args) { return std::vector<decltype(Vec(args...))>(n, Vec(args...)); }
template <typename T>
constexpr T PopCount(T v) { return v = (v & 0x5555555555555555ULL) + (v >> 1 & 0x5555555555555555ULL), v = (v & 0x3333333333333333ULL) + (v >> 2 & 0x3333333333333333ULL), v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL, static_cast<T>(v * 0x0101010101010101ULL >> 56 & 0x7f); }
template <typename T>
constexpr T log2p1(T v) { return v |= (v >> 1), v |= (v >> 2), v |= (v >> 4), v |= (v >> 8), v |= (v >> 16), v |= (v >> 32), PopCount(v); }
template <typename T>
constexpr bool ispow2(const T v) { return (v << 1) == (T(1) << (log2p1(v))); }
template <typename T>
constexpr T ceil2(const T v) { return ispow2(v) ? v : T(1) << log2p1(v); }
template <typename T>
constexpr T floor2(const T v) { return v == 0 ? T(0) : ispow2(v) ? v : T(1) << (log2p1(v) - 1); }
template <typename T>
struct Accum
{
    template <typename InIt>
    Accum(const InIt first, const InIt last) : accum(std::size_t(std::distance(first, last))) { std::partial_sum(first, last, accum.begin()); }
    T sum(const std::size_t i) const { return i == 0 ? T(0) : accum[i - 1]; }
    T sum(const std::size_t l, const std::size_t r) const { return sum(r) - sum(l); }
    std::vector<T> accum;
};
template <typename T>
struct Accum2D
{
    Accum2D(const std::vector<std::vector<T>>& t) : accum{t}
    {
        for (std::size_t i = 0; i < accum.size(); i++) {
            for (std::size_t j = 1; j < accum[i].size(); j++) { accum[i][j] += accum[i][j - 1]; }
        }
        for (std::size_t i = 1; i < accum.size(); i++) {
            for (std::size_t j = 0; j < accum[i].size(); j++) { accum[i][j] += accum[i - 1][j]; }
        }
    }
    T sum(const std::size_t y, const std::size_t x) const { return y == 0 or x == 0 ? T(0) : accum[y - 1][x - 1]; }
    T sum(const std::size_t ymin, const std::size_t ysup, const std::size_t xmin, const std::size_t xsup) const { return sum(ysup, xsup) - sum(ymin, xmin); }
    std::vector<std::vector<T>> accum;
};
template <typename T>
struct Zip
{
    template <typename InIt>
    Zip(const InIt first, const InIt last) : unzip(std::size_t(std::distance(first, last)))
    {
        std::copy(first, last, unzip), std::sort(unzip.begin(), unzip.end()), unzip.erase(std::unique(unzip.begin(), unzip.end()), unzip.end());
        for (std::size_t i = 0; i < unzip.size(); i++) { zip[unzip[i]] = i; }
    }
    std::vector<T> unzip;
    std::map<T, std::size_t> zip;
};
template <typename T, std::size_t N>
std::ostream& operator<<(std::ostream& os, const std::array<T, N>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
template <typename T, typename A>
std::ostream& operator<<(std::ostream& os, const std::deque<T, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
template <typename K, typename T, typename C, typename A>
std::ostream& operator<<(std::ostream& os, const std::multimap<K, T, C, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << "<" << e.first << ": " << e.second << ">,"; }
    return (os << "]" << std::endl);
}
template <typename T, typename C, typename A>
std::ostream& operator<<(std::ostream& os, const std::multiset<T, C, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
template <typename K, typename T, typename C, typename A>
std::ostream& operator<<(std::ostream& os, const std::map<K, T, C, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << "<" << e.first << ": " << e.second << ">,"; }
    return (os << "]" << std::endl);
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& v) { return (os << "<" << v.first << "," << v.second << ">"); }
template <typename T1, typename T2, typename T3>
std::ostream& operator<<(std::ostream& os, const std::priority_queue<T1, T2, T3>& v)
{
    auto q = v;
    os << "[";
    while (not q.empty()) { os << q.top() << ",", q.pop(); }
    return os << "]\n";
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::queue<T1>& v)
{
    auto q = v;
    os << "[";
    while (not q.empty()) { os << q.front() << ",", q.pop(); }
    return os << "]\n";
}
template <typename T, typename C, typename A>
std::ostream& operator<<(std::ostream& os, const std::set<T, C, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::stack<T1>& v)
{
    auto q = v;
    os << "[";
    while (not q.empty()) { os << q.top() << ",", q.pop(); }
    return os << "]\n";
}
template <typename K, typename T, typename H, typename P, typename A>
std::ostream& operator<<(std::ostream& os, const std::unordered_multimap<K, T, H, P, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << "<" << e.first << ": " << e.second << ">,"; }
    return (os << "]" << std::endl);
}
template <typename T, typename H, typename P, typename A>
std::ostream& operator<<(std::ostream& os, const std::unordered_multiset<T, H, P, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
template <typename K, typename T, typename H, typename P, typename A>
std::ostream& operator<<(std::ostream& os, const std::unordered_map<K, T, H, P, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << "<" << e.first << ": " << e.second << ">,"; }
    return (os << "]" << std::endl);
}
template <typename T, typename H, typename P, typename A>
std::ostream& operator<<(std::ostream& os, const std::unordered_set<T, H, P, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
template <typename T, typename A>
std::ostream& operator<<(std::ostream& os, const std::vector<T, A>& v)
{
    os << "[";
    for (const auto& e : v) { os << e << ","; }
    return (os << "]" << std::endl);
}
//!=================================================================================!//
//!  .d88888b  oo                     dP              a88888b. dP     dP  d888888P  !//
//!  88.    "'                        88             d8'   '88 88     88     88     !//
//!  'Y88888b. dP 88d8b.d8b. 88d888b. 88 .d8888b.    88        88aaaaa88a    88     !//
//!        '8b 88 88''88''88 88'  '88 88 88ooood8    88        88     88     88     !//
//!  d8'   .8P 88 88  88  88 88.  .88 88 88.  ...    Y8.   .88 88     88     88     !//
//!   Y88888P  dP dP  dP  dP 88Y888P' dP '88888P'     Y88888P' dP     dP     dP     !//
//!                          88                                                     !//
//!                          dP                                                     !//
//!=================================================================================!//
template <typename T, typename V = T>
struct SimpleCHT
{
    using L = std::pair<T, T>;
    std::vector<L> lines;
    std::size_t head = 0;

public:
    void add(const T a, const T b)
    {
        auto check = [](auto&& self, const L& l1, const L& l2, const L& l3) -> bool { return l1 < l3 ? self(self, l3, l2, l1) : V(l3.second - l2.second) * (l2.first - l1.first) >= V(l2.second - l1.second) * (l3.first - l2.first); };
        while (lines.size() >= 2 and check(check, *(lines.end() - 2), lines.back(), {a, b})) { lines.pop_back(); }
        lines.push_back({a, b});
    }
    V query(const T x)
    {
        auto f = [&](const std::size_t i, const T x) -> V { return (V)lines[i].first * x + lines[i].second; };
        for (; lines.size() - head >= 2 and f(head, x) > f(head + 1, x); head++) {}
        return f(head, x);
    }
};
//!============================================!//
//!    8888ba.88ba             oo              !//
//!    88  '8b  '8b                            !//
//!    88   88   88  .d8888b.  dP  88d888b.    !//
//!    88   88   88  88'  '88  88  88'  '88    !//
//!    88   88   88  88.  .88  88  88    88    !//
//!    dP   dP   dP  '88888P8  dP  dP    dP    !//
//!============================================!//
int main()
{
    int N;
    ll A, B, W;
    std::cin >> N >> A >> B >> W, A *= 2, B *= 2;
    std::vector<ll> D(N + 2, 0LL);
    Rep(N, [&](const int i) { std::cin >> D[i + 1], D[i + 1] *= 2; });
    SimpleCHT<ll, ll> cht;
    std::vector<ll> dp(N + 2, 0LL);
    cht.add(-A - B / 2, A);
    For(1, N + 2, [&](const ll x) {
        dp[x] = B / 2 * x * x + D[x] + cht.query(x);
        cht.add(-A - (x * 2 + 1) * B / 2, dp[x] + (x + 1) * A + x * (x + 1) / 2 * B);
    });
    std::cout << W + dp[N + 1] / 2 << std::endl;
    return 0;
}

yukicoder

結果

テストケース

ソースコード