#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 /////
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
using namespace __gnu_pbds; // find_by_order(), order_of_key()
template<typename TK> using pbds_set = tree<TK, null_type, less<TK>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename TK, typename TV> using pbds_map = tree<TK, TV, less<TK>, rb_tree_tag, tree_order_statistics_node_update>;
*/
struct mpint
{
    static const int D = 9, DD = 1000000000;
    int sign;
    vector<int> data;
    mpint() : sign(1), data(0) {}
    mpint(const string &S) { str2num(S); }
    mpint(lint v) { *this = v; }

    void str2num(const string &S) {
        int buf = 0, ten = 1;
        sign = 1, data.clear();
        IREP(i, S.size())
        {
            if (S[i] == '-') sign *= -1;
            else if (S[i] - '0' >= 0 and S[i] - '0' <= 10)
            {
                buf += (S[i] - '0') * ten;
                ten *= 10;
                if (ten == DD) data.push_back(buf), buf = 0, ten = 1;
            }
        }
        if (buf) data.push_back(buf);
        pop_zero();
    }
    void pop_zero() { while (!data.empty() and !data.back()) data.pop_back(); if (data.empty()) sign = 1; }
    mpint abs() const { mpint ret = *this; ret.sign = 1; return ret; }

    void operator=(const mpint &x) { sign = x.sign, data = x.data; }
    void operator=(lint x) { sign = (x < 0 ? -1 : 1), x = std::abs(x); while(x) data.push_back(x % DD), x /= DD; }
    mpint operator-() const { mpint ret = *this; if (ret.data.size()) ret.sign *= -1; return ret; }
    mpint operator+(const mpint &x) const {
        if (sign == x.sign) {
            mpint ret = *this;
            int now = 0, moveup = 0;
            while (now < (int)x.data.size() or moveup)
            {
                if ((int)ret.data.size() == now) ret.data.push_back(0);
                ret.data[now] += moveup + (now < (int)x.data.size() ? x.data[now] : 0);
                moveup = (ret.data[now] >= DD);
                if (moveup) ret.data[now] -= DD;
                now++;
            }
            return ret;
        }
        else return *this - (-x);
    }
    mpint operator-(const mpint &x) const {
        if (sign == x.sign)
        {
            if (abs() >= x.abs()) {
                mpint ret = *this;
                IREP(i, x.data.size()) {
                    ret.data[i] -= x.data[i];
                    if (ret.data[i] < 0) ret.data[i + 1]--, ret.data[i] += DD;
                }
                ret.pop_zero();
                return ret;
            }
            else return -(x - *this);
        }
        else return *this + (-x);
    }
    bool operator<(const mpint &r) const {
        if (sign != r.sign) return sign < r.sign;
        if (data.size() != r.data.size()) return data.size() * sign < r.data.size() * r.sign;
        IREP(i, data.size()) if (data[i] != r.data[i]) return data[i] * sign < r.data[i] * r.sign;
        return false;
    }
    bool operator>(const mpint &r) const { return r < *this; }
    bool operator<=(const mpint &r) const { return !(r < *this); }
    bool operator>=(const mpint &r) const { return !(*this < r); }
    bool operator==(const mpint &r) const { return sign == r.sign and data == r.data; }
    bool operator!=(const mpint &r) const { return !(*this == r); }
    void operator*=(int x) {
        if (x < 0) sign *= -1, x *= -1;
        int now = 0;
        lint moveup = 0;
        while (now < (int)data.size() or moveup) {
            if (now == (int)data.size()) data.push_back(0);
            moveup = (lint)data[now] * x + moveup;
            data[now] = moveup % DD, moveup /= DD;
            now++;
        }
        pop_zero();
    }
    mpint operator*(int x) const { mpint ret = *this; ret *= x; return ret; }
    void operator/=(int x) {
        if (x < 0) sign *= -1, x *= -1;
        lint buff = 0;
        IREP(i, data.size()) {
            buff = data[i] + buff * DD;
            data[i] = buff / x;
            buff %= x;
        }
        pop_zero();
    }
    mpint operator/(int x) const { mpint ret = *this; ret /= x; return ret; }

    static pair<mpint, mpint> div(const mpint &a1, const mpint &b1) {
        int n = DD / (b1.data.back() + 1);
        mpint a = a1.abs() * n, b = b1.abs() * n, q, r;
        q.data.resize(a.data.size());
        IREP(i, a.data.size())
        {
            r = r * DD + a.data[i];
            int s1 = r.data.size() <= b.data.size() ? 0 : r.data[b.data.size()];
            int s2 = r.data.size() <= b.data.size() - 1 ? 0 : r.data[b.data.size() - 1];
            int d = ((lint)DD * s1 + s2) / b.data.back();
            r -= b * d;
            while (r < 0) r += b, --d;
            q.data[i] = d;
        }
        q.sign = a1.sign * b1.sign, r.sign = a1.sign;
        q.pop_zero(), r.pop_zero();
        return make_pair(q, r / n);
    }

    static mpint shiftd(const mpint &x, int d) {
        mpint ret;
        ret.sign = x.sign, ret.data.assign(x.data.size() + d, 0);
        REP(i, x.data.size()) ret.data[i + d] = x.data[i];
        ret.pop_zero();
        return ret;
    }
    mpint operator*(const mpint &x) const {
        mpint ret;
        REP(i, data.size()) ret += shiftd(x * data[i], i);
        ret.sign *= sign;
        ret.pop_zero();
        return ret;
    }
    mpint operator/(const mpint &x) const { return div(*this, x).first; }
    mpint operator%(const mpint &x) const { return div(*this, x).second; }
    void operator+=(const mpint &x) { *this = *this + x; }
    void operator-=(const mpint &x) { *this = *this - x; }
    void operator*=(const mpint &x) { *this = *this * x; }
    void operator/=(const mpint &x) { *this = *this / x; }
    void operator%=(const mpint &x) { *this = *this % x; }

    friend istream& operator>>(istream &is, mpint &x) {
        string s;
        is >> s;
        x.str2num(s);
        return is;
    }
    friend ostream& operator<<(ostream &os, const mpint &x) {
        if (x.sign == -1) os << '-';
        os << (x.data.empty() ? 0 : x.data.back());
        IREP(i, x.data.size() - 1) os << setw(D) << setfill('0') << x.data[i];
        return os;
    }
};
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 mpint(prv->b - itr->b) * (nxt->a - itr->a) >= mpint(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]);
}