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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;
using static System.Math;
namespace AtCoder
{
    class Program
    {
        static public long[] Sarray() { return ReadLine().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }

        static readonly long Mod = 1000000000 + 7;

        static void Main(string[] args)
        {
            var NC = Sarray();
            var N = NC[0];
            var C = NC[1];
            var H = Sarray();
            var cft = new ConvexFullTric();
            var dp = new int[N].Select(_ => long.MaxValue).ToArray();
            dp[0] = 0;
            for (var i = 1; i < N; ++i)
            {
                cft.add(-2 * H[i - 1], dp[i - 1] + H[i - 1] * H[i - 1]);
                dp[i] = cft.get(H[i]) + H[i] * H[i] + C;
            }
            WriteLine(dp[N - 1]);
        }
        //http://satanic0258.hatenablog.com/entry/2016/08/16/181331
        public class ConvexFullTric
        {
            class pair<T,U>:IComparable<pair<T,U>>where      T:IComparable<T> where U:IComparable<U>
            {
                public T v1;
                public U v2;
                public pair(T v1, U v2)
                {
                    this.v1 = v1;
                    this.v2 = v2;
                }
                public int CompareTo(pair<T, U> a) => v1.CompareTo(a.v1) != 0 ? v1.CompareTo(a.v1) : v2.CompareTo(a.v2);
            }
            //直線群
            List<pair<long, long>> lines;
            public ConvexFullTric()
            {
                lines = new List<pair<long, long>>();
            }
            void swap(pair<long, long> l, pair<long, long> r)
            {
                var t = l; l = r; r = t;
            }
            bool check(pair<long, long> l1, pair<long, long> l2, pair<long, long> l3)
            {
                if (l1.CompareTo(l3) < 0) swap(l1, l3);
                return (l3.v2 - l2.v2) * (l2.v1 - l1.v1) >= (l2.v2 - l1.v2) * (l3.v1 - l2.v1);
            }
            public void add(long a, long b)
            {
                var line = new pair<long, long>(a, b);
                while (2 <= lines.Count && check(lines[lines.Count - 2], lines[lines.Count - 1], line))
                    lines.RemoveAt(lines.Count - 1);
                lines.Add(line);
            }
            long f(int i, long x) => lines[i].v1 * x + lines[i].v2;
            long f(pair<long, long> line, long x) => line.v1 * x + line.v2;
            int head = 0;
            public long get(long x)
            {
                while (2 <= lines.Count - head && f(head + 1, x) < f(head, x))
                    ++head;
                return f(head, x);
            }
        }
    }
}