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: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;

// calc min(a*xs[i] + b)
template <class T>
struct LiCharTree {
  struct Line {
    T a, b;
    Line(T a, T b) : a(a), b(b) {}
    inline T get(T x) const { return a * x + b; }
    inline bool over(const Line &b, const T &x) const {
      return get(x) < b.get(x);
    }
  };
  vector<T> xs;
  vector<Line> seg;
  int xsize;
  LiCharTree() {}
  LiCharTree(const vector<T> &x, T INF) : xs(x) {
    xsize = 1;
    while(xsize < xs.size()) xsize <<= 1;
    while(xs.size() < xsize) xs.push_back(xs.back() + 1);
    seg.assign((xsize << 1) - 1, Line(0, INF));
  }
  void update(Line &x, int k, int l, int r) {
    int mid = (l + r) >> 1;
    bool chl = x.over(seg[k], xs[l]),
         chr = x.over(seg[k], xs[mid]);
    if(chr) swap(seg[k], x);
    if(l + 1 >= r) return;
    if(chl != chr)
      update(x, 2 * k + 1, l, mid);
    else
      update(x, 2 * k + 2, mid, r);
  }
  void update(T a, T b) {
    Line nowl(a, b);
    update(nowl, 0, 0, xsize);
  }
  T query(int k) {
    const T x = xs[k];
    k += xsize - 1;
    T ans = seg[k].get(x);
    while(k > 0) {
      k = (k - 1) >> 1;
      ans = min(ans, seg[k].get(x));
    }
    return ans;
  }
};

long long n, c;
vector<long long> h;
LiCharTree<long long> lct;

long long solve();

int main() {
  cin >> n >> c;
  h.resize(n);
  for(int i = 0; i < n; ++i) cin >> h[i];
  cout << solve() << endl;
  return 0;
}

long long solve() {
  lct = LiCharTree<long long>(h, (long long)(1e16));
  lct.update(0, 0);
  for(int i = 0; i < n; ++i) {
    long long now = lct.query(i) + h[i] * h[i] + c;
    assert(now >= 0 && now <= (long long)(1e16));
    lct.update(-2 * h[i], now + h[i] * h[i]);
    if(i == n - 1) return now;
  }
  assert(0);
  return -1;
}