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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Numerics;
using System.Diagnostics;

class Program
{
    static long GetDistance(int city1, int city2, int[] city, long d)
    {
        if(city1 == city2)
            return long.MaxValue;
        return Math.Abs(city1 - city2) * d + city[city1] + city[city2];
    }
    public void Slove()
    {
        string[] inputs = Console.ReadLine().Split();
        int n = int.Parse(inputs[0]);
        long d = int.Parse(inputs[1]);
        int[] city = 
            Console.ReadLine().Split()
            .Select(int.Parse).ToArray();
        //long[][] distance =
        //    Enumerable.Range(0, n)
        //    .Select(x => new long[n])
        //    .ToArray();
        //foreach(int i in Enumerable.Range(0, n))
        //{
        //    distance[i][i] = long.MaxValue;
        //    foreach(int j in Enumerable.Range(0, n).Skip(i + 1))
        //    {
        //        distance[i][j] = (j - i) * d + city[i] + city[j];
        //        distance[j][i] = distance[i][j];
        //    }
        //}
        bool[] conect = new bool[n];
        conect[0] = true; 
        long cost = 0;
        long[] dp = 
            Enumerable.Range(0, n)
            .Select(x => GetDistance(0, x, city, d)).ToArray();
        foreach(int j in Enumerable.Range(0, n - 1))
        {
            int next = 
                Enumerable.Range(0, n) 
                .Where(x => !conect[x])
                .Aggregate(0, (ret, index) => 
                    dp[index] > dp[ret] ? ret : index);
            //Console.WriteLine(next);
            //Console.WriteLine(string.Join(",", dp));
            cost += dp[next];
            //Console.WriteLine(next);
            conect[next] = true;
            foreach(int i in Enumerable.Range(0, n)
                .Where(x => !conect[x]))
            {
                dp[i] = Math.Min(dp[i], GetDistance(next, i, city, d));
            }
        }
        Console.WriteLine(cost);
    }
    static void Main(string[] args)
    {
        var p = new Program();
        p.Slove();
    }
}