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 Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::collections::BinaryHeap;
use std::collections::HashSet;
use std::io::BufRead;
use std::str::FromStr;
use std::fmt;
use std::str;

struct InputScanner<R: BufRead> {
    reader: R,
    buf: Vec<u8>, // Should never be empty
    pos: usize,   // Should never be out of bounds as long as the input ends with '\n'
}

impl<R: BufRead> InputScanner<R> {
    fn new(reader: R, capacity: usize) -> Self {
        InputScanner {
            reader: reader,
            buf: Vec::with_capacity(capacity),
            pos: 0,
        }
    }

    #[inline]
    fn next<T: FromStr>(&mut self) -> T
    where
        T::Err: fmt::Debug,
    {
        if self.buf.is_empty() {
            self._read_next_line();
        }
        let mut start = None;
        loop {
            match (self.buf[self.pos], start.is_some()) {
                (b' ', true) | (b'\n', true) => break,
                (_, true) | (b' ', false) => self.pos += 1,
                (b'\n', false) => self._read_next_line(),
                (_, false) => start = Some(self.pos),
            }
        }
        let target = &self.buf[start.unwrap()..self.pos];
        unsafe { str::from_utf8_unchecked(target) }.parse().unwrap()
    }

    #[inline]
    fn _read_next_line(&mut self) {
        self.pos = 0;
        self.buf.clear();
        if self.reader.read_until(b'\n', &mut self.buf).unwrap() == 0 {
            panic!("Reached EOF");
        }
    }
}

fn cost(i: usize, j: usize, d: i32, a: &Vec<i32>) -> i64 {
    (i as i64 - j as i64).abs() * d as i64 + a[i] as i64 + a[j] as i64
}

fn main() {
    let stdin = std::io::stdin();
    let mut scanner = InputScanner::new(stdin.lock(), 1000);
    let n: usize = scanner.next();
    let d: i32 = scanner.next();
    let a: Vec<i32> = (0..n).map(|_| scanner.next()).collect();

    let mut heap = BinaryHeap::new();
    heap.push((0, 0));
    let mut visited = HashSet::new();
    let mut res = 0;
    while let Some((c, i)) = heap.pop() {
        if visited.contains(&i) { continue; }
        visited.insert(i);
        res -= c;
        for j in 0..n {
            if !visited.contains(&j) {
                heap.push((-cost(i, j, d, &a), j))
            }
        }
    };

    println!("{}", res)
}