/*

------------------------------------------------------------

i番目の足場に到達するための最小のコストをc[i]とする

c[0] = 0
c[i] = min(j; 0 .. i) (c[j] + (h[i] - h[j])^2 + C)

上記を計算すればよいが、これはもちろんTLE

jのほうを絞り込む

------------------------------------------------------------

c[i] = h[i]^2 + C + min(j; 0 .. i)(-2 h[i] h[j] + c[j] + h[j]^2)

hの一次関数 f[j]: h => -2 h[j] h + c[j] + h[j]^2 を考える
（定義域は h >= h[j]）

これは単調減少、しかも傾きはjが増加するとき減少(負で絶対値が大きくなる)

c[i] = h[i]^2 + C + q(h[i])
hの関数 q(h) = min(j; 0 .. i) f[j](h) は、傾きが単調に増加する折れ線関数 ※jに応じて変わる

「h >= l[k] の範囲では、q(h) = -a[k]h + b[k]」

 (l, a, b)[k] として、lでソートして配列に持っておく

新しいfができたら、それを考慮する
a、bはわかっているがlを求めなければならない

二分探索でf(l) >= q(l) をみたす最大のlをみつける
元々あったl以降は消す

------------------------------------------------------------


*/


import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }


class F{
	long left;
	long a, b;
	this(long a, long b){
		this.a = a;
		this.b = b;
	}
	long opCall(long h){
		return a * h + b;
	}
	override string toString(){
		return a.to!string ~ "x+" ~ b.to!string ~ "(x>=" ~ left.to!string ~ ")";
	}
}

void main(){
	
	// a <= x <=  c の中でfをみたす最大(二分探索; binary search) ※テンプレート版
	T uplimit(T)(T a, T c, bool delegate(T) f){
		if(f(c)) return c; if(! f(a)) return a - 1;
		while(a + 1 < c){ T b = (a + c) / 2; if(f(b)) a = b; else c = b; }
		return a;
	}
	
	long n = read.to!long;
	long c = read.to!long;
	
	long[] hs;
	foreach(i; 0 .. n) hs ~= read.to!long;
	
	long[] cs = new long[](n);
	cs[0] = 0;
	F[] fs = [new F(-2 * hs[0], cs[0] + hs[0] * hs[0])];
	fs[0].left = hs[0];
	foreach(i; 1 .. n){
		// 計算
		long k = uplimit(0, fs.length - 1, (long _) => fs[_].left <= hs[i]);
		cs[i] = hs[i] * hs[i] + c + fs[k](hs[i]);
		debug writeln("k:", k, " cs:", cs);
		
		// 1次関数
		F f = new F(-2 * hs[i], cs[i] + hs[i] * hs[i]);
		f.left = hs[i];
		
		// 挿入するところを見つける
		debug writeln("i:", i, " fs:", fs, " f:", f);
		k = uplimit(0, fs.length - 1, (long _) => fs[_](fs[_].left) <= f(fs[_].left));
		debug writeln("k:", k);
		long l = 1 + uplimit(fs[k].left, hs[n - 1] + 1, (long _) => f(_) > fs[k](_));
		debug writeln("l:", l);
		
		// 挿入
		fs.length = k + 2;
		fs[$ - 1] = f;
		f.left = l;
		debug writeln("fs:", fs);
		
	}
	
	cs[n - 1].writeln;
	
}
