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 <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <functional>
#include <bitset>
#include <numeric>
#include <complex>
#include <iomanip>
#include <cassert>
#include <random>


template<class T, class Comp=std::less<T>>
struct ConvexHullTrick {
public:
    ConvexHullTrick(const Comp &comp = Comp()) : comp(comp) {};

    void add_line(T slope, T intercept) {
        Line line(slope, intercept);
        while (lines.size() >= 2) {
            if (check_valid(*(lines.end() - 2), lines.back(), line)) break;
            lines.pop_back();
        }
        lines.emplace_back(slope, intercept);
    }

    T evaluate(T x) {
        assert(!lines.empty());

        int lo = -1, hi = (int)lines.size() - 1;
        while (hi - lo > 1) {
            int mid = lo + (hi - lo) / 2;
            T v1 = evaluate(lines[mid], x);
            T v2 = evaluate(lines[mid + 1], x);
            if (comp(v1, v2)) hi = mid;
            else lo = mid;
        }
        return evaluate(lines[hi], x);
    }

private:
public:
    const Comp comp;
    using Line = std::pair<T, T>;
    std::vector<Line> lines;

    T check_valid(Line l1, Line l2, Line l3) {
        if (l1.first < l3.first) std::swap(l1, l3);
        T lhs = (l3.second - l2.second)*(l2.first - l1.first);
        T rhs = (l2.second - l1.second)*(l3.first - l2.first);
        return lhs < rhs;
    }

    T evaluate(const Line &line, T x) {
        return line.first*x + line.second;
    }
};


int main() {
    int n; long long c; std::cin >> n >> c;
    std::vector<long long> h(n);
    for (int i = 0; i < n; i++) std::cin >> h[i];
    ConvexHullTrick<long long> cht;
    cht.add_line(-2*h[0], h[0] * h[0] + c);
    for (int i = 1; i < n - 1; i++) {
        long long v = h[i] * h[i] + cht.evaluate(h[i]);
        v += h[i] * h[i] + c;
        cht.add_line(-2*h[i], v);
    }
    std::cout << h[n - 1]*h[n - 1] + cht.evaluate(h[n - 1]) << std::endl;
    return 0;
}