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 For(i, a, b) for(int (i)=(a); (i)<(b); ++(i))
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef pair<int, int> pii;
typedef pair<pii, lint> ppl;
typedef pair<lint, lint> pll;
typedef complex<double> xy_t;
typedef vector<lint> poly;

const lint mod = 1e9 + 7;

typedef  struct ConvexHullTrick{
    deque<pll> dq;

    ConvexHullTrick()= default;

    void addline(lint a3, lint b3){
        while(dq.size() >= 2){
            int sz = dq.size();
            lint a1 = dq[sz-2].fi, b1 = dq[sz-2].se;
            lint a2 = dq[sz-1].fi, b2 = dq[sz-1].se;
            if(a1*b3-a3*b1 <= (b3-b1)*a2 + (a1-a3)*b2) dq.pop_back();
            else break;
        }
        dq.emplace_back(a3, b3);
    }

    lint getmin(lint x){
        while(dq.size() >= 2){
            lint a1 = dq[0].fi, b1 = dq[0].se;
            lint a2 = dq[1].fi, b2 = dq[1].se;
            if(a1*x + b1 >= a2*x + b2) dq.pop_front();
            else break;
        }
        return dq[0].fi * x + dq[0].se;
    }
}CHT;

int main(){
    int n;
    lint c;
    scanf("%d%lld", &n, &c);
    lint h[n];
    rep(i, n) scanf("%lld", &h[i]);

    lint dp[n];
    dp[0] = 0;
    CHT cht;
    cht.addline(-2*h[0], h[0]*h[0] + c);

    For(i, 1, n){
        dp[i] = cht.getmin(h[i]) + h[i]*h[i];
        cht.addline(-2*h[i], h[i]*h[i] + c + dp[i]);
    }

    printf("%lld\n", dp[n-1]);
}