Problem:
Score : 500 points

Problem Statement

There are N towns on a line running east-west.
The towns are numbered 1 through N, in order from west to east.
Each point on the line has a one-dimensional coordinate, and a point that is farther east has a greater coordinate value.
The coordinate of town i is X_i.

You are now at town 1, and you want to visit all the other towns.
You have two ways to travel:

Walk on the line.
Your fatigue level increases by A each time you travel a distance of 1, regardless of direction.

Teleport to any location of your choice.
Your fatigue level increases by B, regardless of the distance covered.

Find the minimum possible total increase of your fatigue level when you visit all the towns in these two ways.

Constraints

All input values are integers.

2≤N≤10^5

1≤X_i≤10^9

For all i(1≤i≤N-1), X_i<X_{i+1}.

1≤A≤10^9

1≤B≤10^9

Input

The input is given from Standard Input in the following format:

N A B
X_1 X_2 ... X_N

Output

Print the minimum possible total increase of your fatigue level when you visit all the towns.

Sample Input 1

4 2 5
1 2 5 7

Sample Output 1

11

From town 1, walk a distance of 1 to town 2, then teleport to town 3, then walk a distance of 2 to town 4.
The total increase of your fatigue level in this case is 2×1+5+2×2=11, which is the minimum possible value.

Sample Input 2

7 1 100
40 43 45 105 108 115 124

Sample Output 2

84

From town 1, walk all the way to town 7.
The total increase of your fatigue level in this case is 84, which is the minimum possible value.

Sample Input 3

7 1 2
24 35 40 68 72 99 103

Sample Output 3

12

Visit all the towns in any order by teleporting six times.
The total increase of your fatigue level in this case is 12, which is the minimum possible value.

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using static System.Math;
using static Math2;
using static Output;

public class CP {
  public void Solve () {
    Input sc = new Input ();
    int n, a, b;
    sc.mul (out n, out a, out b);
    int[] x = sc.cinarr<int> ();
    long ans = 0;
    for (int i = 0; i < n - 1; ++i) {
      var tele = b;
      var toho = (x[i + 1] - x[i]) * a;
      ans += Min (tele, toho);
    }
    Put (ans);

  }

}

public static class Math2 {
  public const int INF = 1 << 29;
  public const long INFL = 1L << 60;
  public const long MOD = 1000000007;
  public const long MOD2 = 998244353;

  public static long Power (long a, long b, long MOD = 1000000007) //i^N
  {
    long res = 1;
    while (b > 0) {
      if ((b & 1) != 0) res = res * a % MOD;
      a = a * a % MOD;
      b >>= 1;
    }
    return res;
  }
  public static long Power2 (long a, long b) //i^N
  {
    long res = 1;
    while (b > 0) {
      if ((b & 1) != 0) res = res * a;
      a = a * a;
      b >>= 1;
    }
    return res;
  }
  public static long GCD (long a, long b) {
    if (a == 0) return b;
    while (b > 0) {
      var r = a % b;
      a = b;
      b = r;
    }
    return a;
  }
  public static long LCM (long a, long b) => (b / GCD (a, b)) * a;
  public static long Comb (long n, long r, int MOD = 1000000007) {
    if (r > n - r) r = n - r;
    long Nume = 1;
    long Deno = 1;

    if (r > n - r) r = n - r;
    for (long i = 1; i <= r; ++i) {
      Deno = (Deno * i) % MOD;
      Nume = Nume * (n - i + 1) % MOD;
    }
    return (Nume * inv (Deno)) % MOD;
  }
  public static long Comb2 (long n, long r) {
    long Nume = 1;
    long Deno = 1;

    if (r > n - r) r = n - r;
    for (long i = 1; i <= r; ++i) {
      Deno *= i;
      Nume *= n - i + 1;
    }
    return Nume / Deno;
  }
  public static long inv (long x, int MOD = 1000000007) {
    return Power (x, MOD - 2, MOD);
  }
}
public static class Utils {
  public static void Swap<T> (ref T A, ref T B) {
    T x = A;
    A = B;
    B = x;
  }
  public static int DigitSum (string N) {

    int ret = 0;
    for (int i = 0; i < N.Length; ++i) ret += N[i] - '0';
    return ret;
  }
  public static string ConvertBase (long N, int K) {
    StringBuilder ret = new StringBuilder ();
    while (N > 0) {
      var r = N % K;
      N /= K;
      ret.Append (r);
    }
    return new string (ret.ToString ().ToCharArray ().Reverse ().ToArray ());
  }
  public static bool NextPermutation<T> (IList<T> lis, Comparison<T> cmp) {
    int n = lis.Count;
    int i = n - 1;
    while (i - 1 >= 0) {
      if (cmp (lis[i - 1], lis[i]) < 0) break;
      --i;
    }
    if (i == 0) return false;
    int j = i;
    while (j + 1 < n) {
      if (cmp (lis[i - 1], lis[j + 1]) > 0) break;
      ++j;
    }
    var _q = lis[j];
    lis[i - 1] = lis[j];
    lis[i - 1] = _q;
    int k = i;
    int l = n - 1;
    while (k < l) {
      var _p = lis[k];
      lis[l] = lis[k];
      lis[l] = _p;

      ++k;
      --l;
    }
    return true;
  }
  public static bool NextPermutation<T> (IList<T> lis) => NextPermutation (lis, Comparer<T>.Default.Compare);
}
public class PriorityQueue<T> {
  List<T> _item;
  public int Count { get { return _item.Count; } }
  bool _isascend { get; set; }
  public T Peek { get { return _item[0]; } }
  Comparison<T> Comp;
  public PriorityQueue (bool IsAscend = true, IEnumerable<T> list = null) : this (Comparer<T>.Default.Compare, IsAscend, list) { }
  public PriorityQueue (Comparison<T> cmp, bool IsAscend = true, IEnumerable<T> list = null) {
    _item = new List<T> ();
    _isascend = IsAscend;
    this.Comp = cmp;
    if (list != null) {
      _item.AddRange (list);
      Build ();
    }
  }

  private int Compare (int i, int j) => (_isascend ? -1 : 1) * Comp (_item[i], _item[j]);
  private void Swap (int i, int j) { var t = _item[i]; _item[i] = _item[j]; _item[j] = t; }
  private int Parent (int i) => (i - 1) >> 1;
  private int Left (int i) => (i << 1) + 1;
  public T Enqueue (T val) {
    int i = _item.Count;
    _item.Add (val);
    while (i > 0) {
      int p = Parent (i);
      if (Compare (i, p) > 0)
        Swap (i, p);
      i = p;
    }
    return val;
  }
  private void Heapify (int index) {
    for (int i = index, j;
      (j = Left (i)) < _item.Count; i = j) {
      if (j != _item.Count - 1 && Compare (j, j + 1) < 0) j++;
      if (Compare (i, j) < 0)
        Swap (i, j);
    }
  }
  public T Dequeue () {
    T val = _item[0];
    _item[0] = _item[_item.Count - 1];
    _item.RemoveAt (_item.Count - 1);
    Heapify (0);
    return val;
  }
  private void Build () {
    for (var i = (_item.Count >> 1) - 1; i >= 0; i--)
      Heapify (i);
  }
  public bool Any () => Count > 0;
}
class Program {
  static void Main (string[] args) {
    var CP = new CP ();
    CP.Solve ();
  }
}
public static class Output {

  public static void Put (string a) => Console.WriteLine (a);
  public static void Put (params object[] i) => Put (string.Join (" ", i));
  public static void Put<T> (IEnumerable<T> a) => Put (string.Join (" ", a));
  public static void PutV<T> (IEnumerable<T> a) { foreach (var z in a) Put (z); }
  public static void YN (bool i) {
    if (i) Put ("Yes");
    else Put ("No");
  }
}
public class Input {
  public static string Str => Console.ReadLine ();
  public static bool IsTypeEqual<T, U> () => typeof (T).Equals (typeof (U));
  public static T ConvertType<T, U> (U a) => (T) Convert.ChangeType (a, typeof (T));
  public static T Cast<T> (string s) {
    if (IsTypeEqual<T, int> ()) return ConvertType<T, int> (int.Parse (s));
    else if (IsTypeEqual<T, long> ()) return ConvertType<T, long> (long.Parse (s));
    else if (IsTypeEqual<T, double> ()) return ConvertType<T, double> (double.Parse (s));
    else if (IsTypeEqual<T, char> ()) return ConvertType<T, char> (char.Parse (s));
    else return ConvertType<T, string> (s);
  }
  public static T[] Castarr<T> (string[] s) {

    var ret = new T[s.Length];
    int i = 0;
    if (IsTypeEqual<T, char> ()) {
      var list = new List<T> ();
      foreach (var t in s) {
        foreach (var u in t) {
          list.Add (ConvertType<T, char> (char.Parse (u.ToString ())));
        }
      }
      return list.ToArray ();
    }
    foreach (var t in s) {
      if (IsTypeEqual<T, int> ()) ret[i++] = ConvertType<T, int> (int.Parse (t));
      else if (IsTypeEqual<T, long> ()) ret[i++] = ConvertType<T, long> (long.Parse (t));
      else if (IsTypeEqual<T, double> ()) ret[i++] = ConvertType<T, double> (double.Parse (t));
      else ret[i++] = ConvertType<T, string> (t);
    }
    return ret;
  }
  Queue<string> q = new Queue<string> ();
  void next () { var ss = Str.Split (' '); foreach (var item in ss) q.Enqueue (item); }
  public T cin<T> () { if (!q.Any ()) next (); return Cast<T> (q.Dequeue ()); }
  public void mul<T> (out T t) { t = cin<T> (); }
  public void mul<T, U> (out T t, out U u) { t = cin<T> (); u = cin<U> (); }
  public void mul<T, U, V> (out T t, out U u, out V v) { t = cin<T> (); u = cin<U> (); v = cin<V> (); }
  public void mul<T, U, V, W> (out T t, out U u, out V v, out W w) { t = cin<T> (); u = cin<U> (); v = cin<V> (); w = cin<W> (); }
  public void mul<T, U, V, W, X> (out T t, out U u, out V v, out W w, out X x) { t = cin<T> (); u = cin<U> (); v = cin<V> (); w = cin<W> (); x = cin<X> (); }
  public void mul<T, U, V, W, X, Y> (out T t, out U u, out V v, out W w, out X x, out Y y) { t = cin<T> (); u = cin<U> (); v = cin<V> (); w = cin<W> (); x = cin<X> (); y = cin<Y> (); }
  public void mul<T, U, V, W, X, Y, Z> (out T t, out U u, out V v, out W w, out X x, out Y y, out Z z) { t = cin<T> (); u = cin<U> (); v = cin<V> (); w = cin<W> (); x = cin<X> (); y = cin<Y> (); z = cin<Z> (); }
  public T[] cinarr<T> () { return Castarr<T> (Str.Split (' ')); }
}