結果

問題 No.913 木の燃やし方
ユーザー hitonanodehitonanode
提出日時 2019-10-20 22:38:56
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 1,194 ms / 3,000 ms
コード長 8,313 bytes
コンパイル時間 2,046 ms
コンパイル使用メモリ 183,292 KB
実行使用メモリ 23,580 KB
最終ジャッジ日時 2024-07-02 17:35:03
合計ジャッジ時間 35,737 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
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 10 ms
5,376 KB
testcase_04 AC 10 ms
5,376 KB
testcase_05 AC 11 ms
5,376 KB
testcase_06 AC 7 ms
5,376 KB
testcase_07 AC 4 ms
5,376 KB
testcase_08 AC 1,042 ms
15,164 KB
testcase_09 AC 1,001 ms
14,668 KB
testcase_10 AC 1,004 ms
14,644 KB
testcase_11 AC 1,025 ms
14,972 KB
testcase_12 AC 1,090 ms
15,672 KB
testcase_13 AC 803 ms
15,164 KB
testcase_14 AC 761 ms
14,668 KB
testcase_15 AC 766 ms
14,776 KB
testcase_16 AC 800 ms
15,164 KB
testcase_17 AC 766 ms
14,796 KB
testcase_18 AC 793 ms
14,648 KB
testcase_19 AC 1,069 ms
23,408 KB
testcase_20 AC 834 ms
15,620 KB
testcase_21 AC 1,017 ms
15,632 KB
testcase_22 AC 996 ms
15,820 KB
testcase_23 AC 990 ms
16,944 KB
testcase_24 AC 1,012 ms
20,028 KB
testcase_25 AC 1,057 ms
23,580 KB
testcase_26 AC 837 ms
15,656 KB
testcase_27 AC 1,194 ms
23,404 KB
testcase_28 AC 971 ms
15,752 KB
testcase_29 AC 956 ms
15,732 KB
testcase_30 AC 982 ms
15,632 KB
testcase_31 AC 981 ms
23,432 KB
testcase_32 AC 988 ms
23,432 KB
testcase_33 AC 990 ms
23,424 KB
testcase_34 AC 831 ms
15,684 KB
testcase_35 AC 851 ms
15,680 KB
testcase_36 AC 864 ms
15,824 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> bool mmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool mmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
template<typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
///// This part below is only for debug, not used /////
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
///// END /////

using T_CHT = lint;
struct ConvexHullTrick
{
    static const T_CHT T_MIN = numeric_limits<T_CHT>::lowest() + 1;
    struct Line
    {
        T_CHT a, b; // y = ax + b
        mutable pair<T_CHT, T_CHT> rp; // (numerator, denominator) `x` coordinate of the crossing point with next line
        Line(T_CHT a, T_CHT b) : a(a), b(b), rp(T_MIN, T_MIN) {}
        static pair<T_CHT, T_CHT> cross(const Line &ll, const Line &lr)
        {
            return make_pair(ll.b - lr.b, lr.a - ll.a); // `ll.a < lr.a` is assumed implicitly
        }
        bool operator<(const Line &r) const
        {
            if (b == T_MIN)
            {
                if (r.rp.first == T_MIN) return true;
                else return a * r.rp.second < r.rp.first;
            }
            else if (r.b == T_MIN)
            {
                if (rp.first == T_MIN) return false;
                else return !(r.a * rp.second < rp.first);
            }
            else return a < r.a;
        }
    };
    struct Lines : multiset<Line>
    {
        bool flg_min; // true iff for minimization
        inline bool isNeedless(iterator itr)
        {
            if (size() == 1) return false;
            auto nxt = next(itr);
            if (itr == begin()) return itr->a == nxt->a and itr->b <= nxt->b;
            else
            {
                auto prv = prev(itr);
                if (nxt == end()) return itr->a == prv->a and itr->b <= prv->b;
                // Prevent overflow
                else return (prv->b - itr->b) * (nxt->a - itr->a) >= (itr->b - nxt->b) * (itr->a - prv->a);
            }
        }
        void add_line(T_CHT a, T_CHT b)
        {
            if (flg_min) a = -a, b = -b;
            auto itr = insert({a, b});
            if (isNeedless(itr)) erase(itr);
            else
            {
                while (next(itr) != end() and isNeedless(next(itr)))
                {
                    erase(next(itr));
                }
                while (itr != begin() and isNeedless(prev(itr)))
                {
                    erase(prev(itr));
                }
                if (next(itr) != end())
                {
                    itr->rp = Line::cross(*itr, *next(itr));
                }
                if (itr != begin())
                {
                    prev(itr)->rp = Line::cross(*prev(itr), *itr);
                }
            }
        }
        Lines(bool is_minimizer): flg_min(is_minimizer) {}
        pair<T_CHT, T_CHT> get(T_CHT x)
        {
            auto itr = lower_bound({x, T_MIN});
            T_CHT retval = T_MIN, reta = T_MIN;
            if (itr != end())
            {
                retval = itr->a * x + itr->b;
                reta = itr->a;
            }
            if (itr != begin())
            {
                T_CHT tmp = prev(itr)->a * x + prev(itr)->b;
                if (tmp >= retval)
                {
                    retval = tmp;
                    reta = max(reta, prev(itr)->a);
                }
            }
            return make_pair(flg_min ? -retval : retval, flg_min ? -reta : reta);
        }
    };
    Lines lines;
    ConvexHullTrick(bool is_minimizer) : lines(is_minimizer) {}
    void add_line(T_CHT a, T_CHT b) { lines.add_line(a, b); } // Add y = ax + b
    pair<T_CHT, T_CHT> get(T_CHT x) { return lines.get(x); }
    void add_convex_parabola(T_CHT c, T_CHT a, T_CHT b) { add_line(-2 * c * a, c * a * a + b); } // Add y = c(x - a)^2 + b
    T_CHT parabola_lower_bound(T_CHT c, T_CHT x) { return lines.get(x).first + c * x * x; }
};
const T_CHT ConvexHullTrick::T_MIN;

constexpr lint INF = 1e10;
int N;
vector<lint> A;
vector<lint> ret;

vector<lint> solve(vector<lint> V, const vector<lint> &W)
{
    ConvexHullTrick cht(true);
    multiset<lint> vm;
    vector<lint> vmdel(V.size());
    lint act = 0;
    REP(i, W.size())
    {
        act += W[i];
        cht.add_convex_parabola(1, -i - 2, act);
    }
    reverse(ALL(V));
    act = 0;
    REP(i, V.size())
    {
        act += V[i];
        lint tmp = cht.parabola_lower_bound(1, i) + act;
        vm.insert(tmp);
        vmdel[i] = tmp;
    }
    vector<lint> ret(V.size());
    REP(i, V.size())
    {
        ret[i] = *vm.begin();
        vm.erase(vm.lower_bound(vmdel[i]));
    }
    reverse(ALL(ret));
    return ret;
}

void divide_and_conquer(int l, int r)
{
    if (r <= l) return;
    if (l + 1 == r)
    {
        mmin(ret[l], 1 + A[l]);
        return;
    }
    if (l + 2 == r)
    {
        mmin(ret[l], 1 + A[l]);
        mmin(ret[l + 1], 1 + A[l + 1]);
        mmin(ret[l], 4 + A[l] + A[l + 1]);
        mmin(ret[l + 1], 4 + A[l] + A[l + 1]);
        return;
    }
    int c = (l + r) / 2;
    divide_and_conquer(l, c);
    divide_and_conquer(c, r);

    vector<lint> VL(c - l), VR(r - c);
    REP(i, c - l) VL[i] = A[l + i];
    REP(i, r - c) VR[i] = A[c + i];
    vector<lint> tmpl = solve(VL, VR);
    reverse(ALL(VL));
    reverse(ALL(VR));
    vector<lint> tmpr = solve(VR, VL);
    reverse(ALL(tmpr));
    REP(i, c - l) mmin(ret[l + i], tmpl[i]);
    REP(i, r - c) mmin(ret[c + i], tmpr[i]);
}

int main()
{
    cin >> N;
    A.resize(N);
    cin >> A;
    ret.assign(N, INF);
    divide_and_conquer(0, N);
    REP(i, N) printf("%lld\n", ret[i]);
}
0