Problem:
Score : 100 points

Problem Statement

There are N stones, numbered 1, 2, \ldots, N.
For each i (1 \leq i \leq N), the height of Stone i is h_i.
Here, h_1 < h_2 < \cdots < h_N holds.

There is a frog who is initially on Stone 1.
He will repeat the following action some number of times to reach Stone N:

If the frog is currently on Stone i, jump to one of the following: Stone i + 1, i + 2, \ldots, N. Here, a cost of (h_j - h_i)^2 + C is incurred, where j is the stone to land on.

Find the minimum possible total cost incurred before the frog reaches Stone N.

Constraints

All values in input are integers.

2 \leq N \leq 2 \times 10^5

1 \leq C \leq 10^{12}

1 \leq h_1 < h_2 < \cdots < h_N \leq 10^6

Input

Input is given from Standard Input in the following format:

N C
h_1 h_2 \ldots h_N

Output

Print the minimum possible total cost incurred.

Sample Input 1

5 6
1 2 3 4 5

Sample Output 1

20

If we follow the path 1 → 3 → 5, the total cost incurred would be ((3 - 1)^2 + 6) + ((5 - 3)^2 + 6) = 20.

Sample Input 2

2 1000000000000
500000 1000000

Sample Output 2

1250000000000

The answer may not fit into a 32-bit integer type.

Sample Input 3

8 5
1 3 4 5 10 11 12 13

Sample Output 3

62

If we follow the path 1 → 2 → 4 → 5 → 8, the total cost incurred would be ((3 - 1)^2 + 5) + ((5 - 3)^2 + 5) + ((10 - 5)^2 + 5) + ((13 - 10)^2 + 5) = 62.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#endif
using namespace std;
using ll = long long;
using ld = long double;
template <typename T> using lim = numeric_limits<T>;
template <typename T> istream& operator>>(istream& is, vector<T>& a) { for(T& x : a) { is >> x; } return is; }
template <typename Iter, typename T> int gt(Iter L, Iter R, T v) { return upper_bound(L, R, v) - L; }
template <typename Iter, typename T> int ge(Iter L, Iter R, T v) { return lower_bound(L, R, v) - L; }
template <typename Iter, typename T> int lt(Iter L, Iter R, T v) { return lower_bound(L, R, v) - L - 1; }
template <typename Iter, typename T> int le(Iter L, Iter R, T v) { return upper_bound(L, R, v) - L - 1; }
template <typename Bst, typename T> typename Bst::const_iterator gt(const Bst& bst, T v) { return bst.upper_bound(v); }
template <typename Bst, typename T> typename Bst::const_iterator ge(const Bst& bst, T v) { return bst.lower_bound(v); }
template <typename Bst, typename T> typename Bst::const_iterator lt(const Bst& bst, T v) { return bst.lower_bound(v) == bst.begin() ? bst.end() : --bst.lower_bound(v); }
template <typename Bst, typename T> typename Bst::const_iterator le(const Bst& bst, T v) { return bst.upper_bound(v) == bst.begin() ? bst.end() : --bst.upper_bound(v); }
// maintain an upper/lower hull L of lines y = mx + b
// query for y(x) such that y(x) is minimum/maximum over all lines y in L
// assumes lines are inserted in non-increasing/non-decreasing order of m
// minimization by default, call constructor with greater<ll>() for maximization
struct cht {
    struct line {
        ll m, b, intersection;
        ll eval(ll x) const { return m * x + b; }
        ll cross(const line& l) const { return (l.b - b) / (m - l.m); }
        bool operator<(const line& l) const { return m > l.m; }
        bool operator<(const ll x) const { return intersection < x; }
        friend bool operator<(const ll x, const line& l) { return x < l.intersection; }
    };
    multiset<line, less<>> h;
    const function<bool(ll, ll)> cmp;
    cht(const function<bool(ll, ll)>& cmp = less<ll>()) : cmp(cmp) {}
    const line& l1() { return *h.rbegin(); }
    const line& l2() { return *++h.rbegin(); }
    void pop() { h.erase(--h.end()); }
    void add(ll m, ll b) {
        if(h.empty()) {
            h.insert({m, b, numeric_limits<ll>::min()});
        } else if(m != l1().m or cmp(b, l1().b)) {
            if(m == l1().m) pop();
            while(h.size() >= 2 and l1().cross({m, b}) <= l1().cross(l2())) pop();
            h.insert({m, b, l1().cross({m, b})});
        }
    }
    ll opt(ll x) {
        assert(!h.empty());
        ll y1 = lt(h, x)->eval(x), y2 = le(h, x)->eval(x);
        return cmp(y1, y2) ? y1 : y2;
    }
};
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n;
    ll c;
    cin >> n >> c;
    vector<ll> h(n);
    cin >> h;
    cht cht;
    auto opt = [&](int j) { return j ? h[j] * h[j] + cht.opt(h[j]) : 0; };
    for(int j = 0; j < n; j++) {
        cht.add(-2 * h[j], h[j] * h[j] + c + opt(j));
    }
    cout << opt(n - 1) << endl;
    return 0;
}