Problem:
Score : 600 points

Problem Statement

There are N cities in Republic of AtCoder. The size of the i-th city is A_{i}.
Takahashi would like to build N-1 bidirectional roads connecting two cities so that any city can be reached from any other city by using these roads.

Assume that the cost of building a road connecting the i-th city and the j-th city is |i-j| \times D + A_{i} + A_{j}.
For Takahashi, find the minimum possible total cost to achieve the objective.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq D \leq 10^9

1 \leq A_{i} \leq 10^9

A_{i} and D are integers.

Input

Input is given from Standard Input in the following format:

N D
A_1 A_2 ... A_N

Output

Print the minimum possible total cost.

Sample Input 1

3 1
1 100 1

Sample Output 1

106

This cost can be achieved by, for example, building roads connecting City 1, 2 and City 1, 3.

Sample Input 2

3 1000
1 100 1

Sample Output 2

2202

Sample Input 3

6 14
25 171 7 1 17 162

Sample Output 3

497

Sample Input 4

12 5
43 94 27 3 69 99 56 25 8 15 46 8

Sample Output 4

658

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

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

class union_find {
 private:
  vector<int> parent;
  vector<int> rank;

 public:
  union_find(int n) : parent(n), rank(n) {
    for (int i = 0; i < n; i++) parent[i] = i;
  }
  void unite(int a, int b) {
    a = find(a);
    b = find(b);
    if (a == b) return;
    if (rank[a] < rank[b]) {
      parent[a] = b;
    } else {
      parent[b] = a;
      if (rank[a] == rank[b]) rank[a]++;
    }
  }
  int find(int a) { return parent[a] == a ? a : parent[a] = find(parent[a]); }
};

int main() {
  int n, d;
  cin >> n >> d;
  vector<int> a(n);
  for (auto &e : a) cin >> e;

  union_find u(n);
  vector<int> s(n, 1);
  vector<pair<int, int>> c(n);
  for (int i = 0; i < n; i++) {
    c[i].first = c[i].second = a[i];
  }
  ll r = 0;
  while (u.find(0) != u.find(n - 1)) {
    int mi = 0;
    ll mc = 1e16;
    for (int i = 0; i < n - 1; i++) {
      if (u.find(i) == u.find(i + 1)) {
        continue;
      }
      ll tc = c[u.find(i)].second + c[u.find(i + 1)].first + d;
      if (tc < mc) {
        mi = i;
        mc = tc;
      }
    }
    int u1 = u.find(mi), u2 = u.find(mi + 1);
    c[u1].first = min(c[u1].first, c[u2].first + d * s[u1]);
    c[u1].second = min(c[u1].second + d * s[u2], c[u2].second);
    s[u1] += s[u2];
    u.unite(mi, mi + 1);
    // cerr << mi << " " << mc << endl;
    r += mc;
  }
  cout << r << endl;
}