import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();

        long a[] = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();

        long ans = 0;
        int l = 0, r = n - 1;
        while (l + 1 < n && a[l + 1] > a[l])
            l++;
        while (r - 1 > 0 && a[r - 1] > a[r])
            r--;

        while (l < r) {
            if (a[l] < a[r]) {
                ans += (a[l] + 1) - a[l + 1];
                a[l + 1] = a[l] + 1;
            } else if (a[l] > a[r]) {
                ans += (a[r] + 1) - a[r - 1];
                a[r - 1] = a[r] + 1;
            } else /* a[l] == a[r] */ {
                if (a[l] - a[l + 1] < a[r] - a[r - 1]) {
                    ans += (a[l] + 1) - a[l + 1];
                    a[l + 1] = a[l] + 1;
                } else {
                    ans += (a[r] + 1) - a[r - 1];
                    a[r - 1] = a[r] + 1;
                }
            }

            while (l < n && a[l + 1] > a[l])
                l++;
            while (r > 0 && a[r - 1] > a[r])
                r--;
        }

        out.println(ans);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();

        long a[] = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();

        long ans = 0;
        int l = 0, r = --n;

        while (l < n && a[l + 1] > a[l])
            l++;
        while (r > 1 && a[r - 1] > a[r])
            r--;

        long al = a[l], ar = a[r];

        while (l + 1 < r) {
            if (al < ar)
                ans += (++al) - a[++l];
            else if (al > ar)
                ans += (++ar) - a[--r];
            else if (al + a[r - 1] < ar + a[l + 1])
                ans += (++al) - a[++l];
            else
                ans += (++ar) - a[--r];

            while (l < n && a[l + 1] > al)
                al = a[++l];
            while (r > 1 && a[r - 1] > ar)
                ar = a[--r];
        }

        if (l < r && al == ar)
            ans++;

        out.println(ans);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();

        long a[] = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();

        long ans = 0;
        int l = 0, r = n - 1;
        while (l + 1 < n && a[l + 1] > a[l])
            l++;
        while (r > 0 && a[r - 1] > a[r])
            r--;

        while (l < r) {
            if (a[l] < a[r]) {
                ans += (a[l] + 1) - a[l + 1];
                a[l + 1] = a[l] + 1;
            } else if (a[l] > a[r]) {
                ans += (a[r] + 1) - a[r - 1];
                a[r - 1] = a[r] + 1;
            } else /* a[l] == a[r] */ {
                if (a[l] - a[l + 1] < a[r] - a[r - 1]) {
                    ans += (a[l] + 1) - a[l + 1];
                    a[l + 1] = a[l] + 1;
                } else {
                    ans += (a[r] + 1) - a[r - 1];
                    a[r - 1] = a[r] + 1;
                }
            }

            while (l + 1 < n && a[l + 1] > a[l])
                l++;
            while (r > 0 && a[r - 1] > a[r])
                r--;
        }

        out.println(ans);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

import static java.lang.Math.max;
import static java.lang.Math.min;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();

        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();

        long[] sumL = new long[n], l = new long[n];
        sumL[0] = 0;
        l[0] = a[0];
        for (int i = 1; i < n; i++) {
            l[i] = max(l[i - 1] + 1, a[i]);
            sumL[i] = sumL[i - 1] + (l[i] - a[i]);
        }

        long[] sumR = new long[n], r = new long[n];
        sumR[n - 1] = 0;
        r[n - 1] = a[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            r[i] = max(r[i + 1] + 1, a[i]);
            sumR[i] = sumR[i + 1] + (r[i] - a[i]);
        }

        long ans = min(sumL[n - 1], sumR[0]);
        for (int i = 1; i + 1 < n; i++)
            ans = min(ans, min(sumL[i - 1] + sumR[i] + (l[i - 1] == r[i] ? 1 : 0),
                    sumL[i] + sumR[i + 1] + (l[i] == r[i + 1] ? 1 : 0)));

        out.println(ans);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

import static java.lang.Math.max;
import static java.lang.Math.min;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();

        long a[] = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();

        long ans = 0;
        int l = 0, r = n - 1;
        while (l + 1 < n && a[l + 1] > a[l])
            l++;
        while (r - 1 > 0 && a[r - 1] > a[r])
            r--;

        while (l < r) {
            if (a[l] < a[r]) {
                ans += (a[l] + 1) - a[l + 1];
                a[l + 1] = a[l] + 1;
            } else if (a[l] > a[r]) {
                ans += (a[r] + 1) - a[r - 1];
                a[r - 1] = a[r] + 1;
            } else /* a[l] == a[r] */ {
                if (a[l] - a[l + 1] < a[r] - a[r - 1]) {
                    ans += (a[l] + 1) - a[l + 1];
                    a[l + 1] = a[l] + 1;
                } else {
                    ans += (a[r] + 1) - a[r - 1];
                    a[r - 1] = a[r] + 1;
                }
            }

            while (l + 1 < n && a[l + 1] > a[l])
                l++;
            while (r - 1 > 0 && a[r - 1] > a[r])
                r--;
        }

        out.println(ans);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

import static java.lang.Math.max;
import static java.lang.Math.min;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();

        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();

        long[] l = new long[n];
        l[0] = 0;
        long cur = a[0];
        for (int i = 1; i < n; i++) {
            cur = max(cur + 1, a[i]);
            l[i] = l[i - 1] + (cur - a[i]);
        }

        long[] r = new long[n];
        r[n - 1] = 0;
        cur = a[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            cur = max(cur + 1, a[i]);
            r[i] = r[i + 1] + (cur - a[i]);
        }

        long ans = min(l[n - 1], r[0]);
        for (int i = 1; i + 1 < n; i++)
            ans = min(ans, min(l[i - 1] + r[i], l[i] + r[i + 1]));

        out.println(ans);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean ready() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.awt.*;
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Throwable e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Thread(null, new Main(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    void solve() throws IOException {
        int n = readInt();
        int[] array = readIntArray(n);

        long[] left = new long[n];
        long[] left_peak = new long[n];
        long[] right = new long[n];
        long[] right_peak = new long[n];

        left[0] = 0;
        left_peak[0] = array[0];

        for (int i = 1; i < n; i++) {
            if (array[i] > left_peak[i-1]){
                left_peak[i] = array[i];
                left[i] = left[i - 1];
            } else {
                left_peak[i] = left_peak[i - 1] + 1;
                left[i] = left[i - 1] + (left_peak[i] - array[i]);
            }
        }

        right[n - 1] = 0;
        right_peak[n - 1] = array[n - 1];

        for (int i = n - 2; i >= 0; i--) {
            if (array[i] > right_peak[i + 1]){
                right_peak[i] = array[i];
                right[i] = right[i + 1];
            } else {
                right_peak[i] = right_peak[i + 1] + 1;
                right[i] = right[i + 1] + (right_peak[i] - array[i]);
            }
        }

        long result = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            long cost = left[i];
            if (i < n - 1){
                cost += right[i + 1];
                if (left_peak[i] == right_peak[i + 1]) cost++;
            }
            result = Math.min(result, cost);
        }

        out.print(result);
    }
}


import java.awt.*;
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Throwable e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Thread(null, new Main(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    void solve() throws IOException {
        int n = readInt();
        int[] array = readIntArray(n);

        long[] left = new long[n];
        long[] left_peak = new long[n];
        long[] right = new long[n];
        long[] right_peak = new long[n];

        left[0] = 0;
        left_peak[0] = array[0];

        for (int i = 1; i < n; i++) {
            if (array[i] > left_peak[i-1]){
                left_peak[i] = array[i];
                left[i] = left[i - 1];
            } else {
                left_peak[i] = left_peak[i - 1] + 1;
                left[i] = left[i - 1] + (left_peak[i] - array[i]);
            }
        }

        right[n - 1] = 0;
        right_peak[n - 1] = array[n - 1];

        for (int i = n - 2; i >= 0; i--) {
            if (array[i] > right_peak[i + 1]){
                right_peak[i] = array[i];
                right[i] = right[i + 1];
            } else {
                right_peak[i] = right_peak[i + 1] + 1;
                right[i] = right[i + 1] + (right_peak[i] - array[i]);
            }
        }

        long result = Long.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            long cost = left[i];
            if (i < n - 1){
                cost += right[i + 1];
                if (left_peak[i] == right_peak[i + 1]) cost++;
            }
            result = Math.min(result, cost);
        }

        out.print(result);
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class H_NEERC_2017 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        int[] data = new int[n];
        for (int i = 0; i < n; i++) {
            data[i] = in.nextInt();
        }
        int[]maxL = new int[n];
        int[]maxR = new int[n];
        maxR[n - 1] = n - 1;
        for(int i = 1; i < n; i++){
            int expected = i - maxL[i - 1] + data[maxL[i - 1]];
            if(expected <= data[i]){
                maxL[i] = i;
            }else{
                maxL[i] = maxL[i - 1];
            }
        }
        int right = 0;
        for(int i = n -2; i>= 0; i--){
            int expected = maxR[i + 1] - i + data[maxR[i + 1]];
            if(expected <= data[i]){
                maxR[i] = i;
            }else{
                maxR[i] = maxR[i + 1];
            }
            right += Integer.max(0, expected - data[i]);
        }
        int result = Integer.MAX_VALUE;
        int left = 0;
        for(int i = 0; i < n; i++){
            int expectedLeft = i > 0 ? i - maxL[i - 1] + data[maxL[i - 1]] : 0;
            int expectedRight = i + 1 < n  ? maxR[i + 1] - i + data[maxR[i + 1]] : 0;

            right -= Integer.max(0, expectedRight - data[i]);
            int v = left + right + Integer.max(0, Integer.max(expectedLeft, expectedRight) - data[i]);
            result = Integer.min(result, v);
            left += Integer.max(0, expectedLeft - data[i]);
        }
        out.println(result);
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class H_NEERC_2017 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        long[] data = new long[n];
        for (int i = 0; i < n; i++) {
            data[i] = in.nextInt();
        }
        int[]maxL = new int[n];
        int[]maxR = new int[n];
        maxR[n - 1] = n - 1;
        for(int i = 1; i < n; i++){
            long expected = i - maxL[i - 1] + data[maxL[i - 1]];
            if(expected <= data[i]){
                maxL[i] = i;
            }else{
                maxL[i] = maxL[i - 1];
            }
        }
        long right = 0;
        for(long i = n -2; i>= 0; i--){
            long expected = maxR[i + 1] - i + data[maxR[i + 1]];
            if(expected <= data[i]){
                maxR[i] = i;
            }else{
                maxR[i] = maxR[i + 1];
            }
            right += Long.max(0, expected - data[i]);
        }
        long result = Long.MAX_VALUE;
        long left = 0;
        for(int i = 0; i < n; i++){
            long expectedLeft = i > 0 ? i - maxL[i - 1] + data[maxL[i - 1]] : 0;
            long expectedRight = i + 1 < n  ? maxR[i + 1] - i + data[maxR[i + 1]] : 0;

            right -= Long.max(0, expectedRight - data[i]);
            long v = left + right + Long.max(0, Long.max(expectedLeft, expectedRight) - data[i]);
            result = Long.min(result, v);
            left += Long.max(0, expectedLeft - data[i]);
        }
        out.println(result);
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class H_NEERC_2017 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        long[] data = new long[n];
        for (int i = 0; i < n; i++) {
            data[i] = in.nextInt();
        }
        int[]maxL = new int[n];
        int[]maxR = new int[n];
        maxR[n - 1] = n - 1;
        for(int i = 1; i < n; i++){
            long expected = i - maxL[i - 1] + data[maxL[i - 1]];
            if(expected <= data[i]){
                maxL[i] = i;
            }else{
                maxL[i] = maxL[i - 1];
            }
        }
        long right = 0;
        for(int i = n -2; i>= 0; i--){
            long expected = maxR[i + 1] - i + data[maxR[i + 1]];
            if(expected <= data[i]){
                maxR[i] = i;
            }else{
                maxR[i] = maxR[i + 1];
            }
            right += Long.max(0, expected - data[i]);
        }
        long result = Long.MAX_VALUE;
        long left = 0;
        for(int i = 0; i < n; i++){
            long expectedLeft = i > 0 ? i - maxL[i - 1] + data[maxL[i - 1]] : 0;
            long expectedRight = i + 1 < n  ? maxR[i + 1] - i + data[maxR[i + 1]] : 0;

            right -= Long.max(0, expectedRight - data[i]);
            long v = left + right + Long.max(0, Long.max(expectedLeft, expectedRight) - data[i]);
            result = Long.min(result, v);
            left += Long.max(0, expectedLeft - data[i]);
        }
        out.println(result);
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class H_NEERC_2017 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        long[] data = new long[n];
        for (int i = 0; i < n; i++) {
            data[i] = in.nextInt();
        }
        int[]maxL = new int[n];
        int[]maxR = new int[n];
        maxR[n - 1] = n - 1;
        for(int i = 1; i < n; i++){
            long expected = i - maxL[i - 1] + data[maxL[i - 1]];
            if(expected <= data[i]){
                maxL[i] = i;
            }else{
                maxL[i] = maxL[i - 1];
            }
        }
        long right = 0;
        for(int i = n -2; i>= 0; i--){
            long expected = maxR[i + 1] - i + data[maxR[i - 1]];
            if(expected <= data[i]){
                maxR[i] = i;
            }else{
                maxR[i] = maxR[i + 1];
            }
            right += Long.max(0, expected - data[i]);
        }
        long result = Long.MAX_VALUE;
        long left = 0;
        for(int i = 0; i < n; i++){
            long expectedLeft = i > 0 ? i - maxL[i - 1] + data[maxL[i - 1]] : 0;
            long expectedRight = i + 1 < n  ? maxR[i + 1] - i + data[maxR[i + 1]] : 0;

            right -= Long.max(0, expectedRight - data[i]);
            long v = left + right + Long.max(0, Long.max(expectedLeft, expectedRight) - data[i]);
            result = Long.min(result, v);
            left += Long.max(0, expectedLeft - data[i]);
        }
        out.println(result);
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.util.*;
import java.io.*;

/**
 * 19-Sep-2017
 * 1:37:01 AM
 * @author HulkBuster
 *
 */
public class CF847H {
public static int mod = (int) (1e9 + 7);
public static InputReader in;
public static PrintWriter out;

public static void solve() throws FileNotFoundException {

	in = new InputReader(System.in);
	out = new PrintWriter(System.out);
	int n = in.ni();
	int ar[] = in.nIArr(n);
	int iar[] = new int[n];
	int dar[] = new int[n];

	iar[0]=ar[0];
	for(int i=1;i<n;i++){
		iar[i] = Math.max(iar[i-1]+1, ar[i]);
	}
	dar[n-1] = ar[n-1];
	for(int i=n-2;i>=0;i--){
		dar[i] = Math.max(dar[i+1]+1, ar[i]);
	}
	long cost = 0;
	for(int i=0;i<n;i++){
		cost +=Math.min(Math.abs(ar[i]-iar[i]),Math.abs(ar[i]-dar[i]) );
	}
	out.println(cost);
	out.close();
}

public static void main(String[] args) {
	new Thread(null, new Runnable() {
		public void run() {
			try {
				solve();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}, "1", 1 << 26).start();
}

static class Pair implements Comparable<Pair> {

	int x, y, i;

	Pair(int x, int y, int i) {
		this.x = x;
		this.y = y;
		this.i = i;
	}

	Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int compareTo(Pair o) {
		if (this.x != o.x)
			return Integer.compare(this.x, o.x);
		else
			return Integer.compare(this.y, o.y);
		//return 0;
	}

	public boolean equals(Object o) {
		if (o instanceof Pair) {
			Pair p = (Pair) o;
			return p.x == x && p.y == y && p.i == i;
		}
		return false;
	}

	public int hashCode() {
		return new Integer(x).hashCode() * 31 + new Integer(y).hashCode() + new Integer(i).hashCode() * 37;
	}

}

public static long add(long a, long b) {
	long x = (a + b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static long sub(long a, long b) {
	long x = (a - b);
	while (x < 0)
		x += mod;
	return x;
}

public static long mul(long a, long b) {
	long x = (a * b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static boolean isPal(String s) {
	for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
		if (s.charAt(i) != s.charAt(j))
			return false;
	}
	return true;
}

public static String rev(String s) {
	StringBuilder sb = new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

public static long gcd(long x, long y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static int gcd(int x, int y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static long gcdExtended(long a, long b, long[] x) {

	if (a == 0) {
		x[0] = 0;
		x[1] = 1;
		return b;
	}
	long[] y = new long[2];
	long gcd = gcdExtended(b % a, a, y);

	x[0] = y[1] - (b / a) * y[0];
	x[1] = y[0];

	return gcd;
}

public static long mulmod(long a, long b, long m) {
	if (m <= 1000000009)
		return a * b % m;

	long res = 0;
	while (a > 0) {
		if ((a & 1) != 0) {
			res += b;
			if (res >= m)
				res -= m;
		}
		a >>= 1;
		b <<= 1;
		if (b >= m)
			b -= m;
	}
	return res;
}

public static int abs(int a, int b) {
	return (int) Math.abs(a - b);
}

public static long abs(long a, long b) {
	return (long) Math.abs(a - b);
}

public static int max(int a, int b) {
	if (a > b)
		return a;
	else
		return b;
}

public static int min(int a, int b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long max(long a, long b) {
	if (a > b)
		return a;
	else
		return b;
}

public static long min(long a, long b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long pow(long n, long p, long m) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		if (result >= m)
			result %= m;
		p >>= 1;
		n *= n;
		if (n >= m)
			n %= m;
	}
	return result;
}

public static long pow(long n, long p) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		p >>= 1;
		n *= n;
	}
	return result;
}

public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

static class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int snext() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int ni() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nl() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nIArr(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = ni();
		}
		return a;
	}

	public long[] nLArr(int n) {
		long a[] = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nl();
		}
		return a;
	}

	public String readString() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = snext();
		while (isSpaceChar(c))
			c = snext();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

}
}


import java.util.*;
import java.io.*;

/**
 * 19-Sep-2017
 * 1:37:01 AM
 * @author HulkBuster
 *
 */
public class CF847H {
public static int mod = (int) (1e9 + 7);
public static InputReader in;
public static PrintWriter out;

public static void solve() throws FileNotFoundException {

	in = new InputReader(System.in);
	out = new PrintWriter(System.out);
	int n = in.ni();
	int ar[] = in.nIArr(n);
	int iar[] = new int[n];
	int dar[] = new int[n];

	iar[0]=ar[0];
	for(int i=1;i<n;i++){
		iar[i] = Math.max(iar[i-1]+1, ar[i]);
	}
	dar[n-1] = ar[n-1];
	for(int i=n-2;i>=0;i--){
		dar[i] = Math.max(dar[i+1]+1, ar[i]);
	}
	long cost = 0;
	int x = iar[0]-ar[0];
	int y = dar[0]-ar[0];
	if(x<=y)
		ar[0] = iar[0];
	else
		ar[0] = dar[0];
	//out.print(ar[0]+" ");
	for(int i=1;i<n;i++){
		x = iar[i]-ar[i];
		y = dar[i]-ar[i];
		if(x<=y){
			if(ar[i-1]!=iar[i]){
				cost+=x;
				ar[i] = iar[i];
			}
			else{
				cost+=y;
				ar[i] = dar[i];
			}
		}
		else {
			if(ar[i-1]!=dar[i]){
				cost+=y;
				ar[i] = dar[i];
			}
			else{
				cost+=x;
				ar[i] = iar[i];
			}
		}
		//out.print(ar[i]+" ");
	}
	//out.println();
	out.println(cost);
	out.close();
}

public static void main(String[] args) {
	new Thread(null, new Runnable() {
		public void run() {
			try {
				solve();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}, "1", 1 << 26).start();
}

static class Pair implements Comparable<Pair> {

	int x, y, i;

	Pair(int x, int y, int i) {
		this.x = x;
		this.y = y;
		this.i = i;
	}

	Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int compareTo(Pair o) {
		if (this.x != o.x)
			return Integer.compare(this.x, o.x);
		else
			return Integer.compare(this.y, o.y);
		//return 0;
	}

	public boolean equals(Object o) {
		if (o instanceof Pair) {
			Pair p = (Pair) o;
			return p.x == x && p.y == y && p.i == i;
		}
		return false;
	}

	public int hashCode() {
		return new Integer(x).hashCode() * 31 + new Integer(y).hashCode() + new Integer(i).hashCode() * 37;
	}

}

public static long add(long a, long b) {
	long x = (a + b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static long sub(long a, long b) {
	long x = (a - b);
	while (x < 0)
		x += mod;
	return x;
}

public static long mul(long a, long b) {
	long x = (a * b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static boolean isPal(String s) {
	for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
		if (s.charAt(i) != s.charAt(j))
			return false;
	}
	return true;
}

public static String rev(String s) {
	StringBuilder sb = new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

public static long gcd(long x, long y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static int gcd(int x, int y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static long gcdExtended(long a, long b, long[] x) {

	if (a == 0) {
		x[0] = 0;
		x[1] = 1;
		return b;
	}
	long[] y = new long[2];
	long gcd = gcdExtended(b % a, a, y);

	x[0] = y[1] - (b / a) * y[0];
	x[1] = y[0];

	return gcd;
}

public static long mulmod(long a, long b, long m) {
	if (m <= 1000000009)
		return a * b % m;

	long res = 0;
	while (a > 0) {
		if ((a & 1) != 0) {
			res += b;
			if (res >= m)
				res -= m;
		}
		a >>= 1;
		b <<= 1;
		if (b >= m)
			b -= m;
	}
	return res;
}

public static int abs(int a, int b) {
	return (int) Math.abs(a - b);
}

public static long abs(long a, long b) {
	return (long) Math.abs(a - b);
}

public static int max(int a, int b) {
	if (a > b)
		return a;
	else
		return b;
}

public static int min(int a, int b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long max(long a, long b) {
	if (a > b)
		return a;
	else
		return b;
}

public static long min(long a, long b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long pow(long n, long p, long m) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		if (result >= m)
			result %= m;
		p >>= 1;
		n *= n;
		if (n >= m)
			n %= m;
	}
	return result;
}

public static long pow(long n, long p) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		p >>= 1;
		n *= n;
	}
	return result;
}

public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

static class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int snext() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int ni() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nl() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nIArr(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = ni();
		}
		return a;
	}

	public long[] nLArr(int n) {
		long a[] = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nl();
		}
		return a;
	}

	public String readString() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = snext();
		while (isSpaceChar(c))
			c = snext();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

}
}


//package neerc2017;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class H {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = ni();
		int[] a = na(n);
		long[][] L = makeInc(a);
		a = rev(a);
		long[][] R = makeInc(a);
		a = rev(a);

		long ans = Long.MAX_VALUE;
		for(int i = 0;i < n;i++){
//			tr(i, L[0][i], R[0][n-1-i], L[1][i+1], R[1][n-i], a[i], Math.max(L[1][i+1], R[1][n-i]) - a[i], L[0][i] + R[0][n-1-i] + Math.max(L[1][i+1], R[1][n-i]) - a[i]);
			ans = Math.min(ans, L[0][i] + R[0][n-1-i] + Math.max(L[1][i+1], R[1][n-i]) - a[i]);
		}
		out.println(ans);
	}

	public static int[] rev(int[] a)
	{
		for(int i = 0, j = a.length-1;i < j;i++,j--){
			int c = a[i]; a[i] = a[j]; a[j] = c;
		}
		return a;
	}

	long[][] makeInc(int[] a)
	{
		int n = a.length;
		long[] b = new long[n+1];
		long[] inc = new long[n+1];
		for(int i = 0;i < n;i++){
			if(b[i] >= a[i]){
				inc[i+1] = inc[i] + (b[i] + 1 - a[i]);
				b[i+1] = b[i] + 1;
			}else{
				inc[i+1] = inc[i];
				b[i+1] = a[i];
			}
		}
		return new long[][]{inc, b};
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new H().run(); }

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


import java.io.*;
import java.util.*;

public class Main {
    static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    static final int[][] STEPS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    void solve() throws IOException {
        int n = readInt();
        int[] a = readIntArray(n);
        long lAns[] = new long[n];
        long rAns[] = new long[n];
        long rVal = a[0];
        for (int i = 1; i < n; i++) {
            rAns[i] = rAns[i - 1] + maxLong(0, rVal - a[i] + 1);
            rVal = maxLong(rVal + 1, a[i]);
        }
        long lVal = a[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            lAns[i] = lAns[i + 1]
                    + maxLong(0, lVal - a[i] + 1);
            lVal = maxLong(lVal + 1, a[i]);
        }
        long answer = minLong(lAns[0], rAns[n - 1]);
        for (int i = 0; i < n - 1; i++) {
            answer = minLong(answer, rAns[i] + lAns[i + 1]);
        }
        out.println(answer);

    }

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
        tok = new
                StringTokenizer("");
    }

    int minInt(int... values) {
        int min = Integer.MAX_VALUE;
        for (int value : values) {
            min = Math.min(min, value);
        }
        return min;
    }

    int maxInt(int... values) {
        int max = Integer.MIN_VALUE;
        for (int value : values) {
            max = Math.max(max, value);
        }
        return max;
    }

    long minLong(long... values) {
        long min = Long.MAX_VALUE;
        for (long value : values) {
            min = Math.min(min, value);
        }
        return min;
    }

    long maxLong(long... values) {
        long max = Long.MIN_VALUE;
        for (long value : values) {
            max = Math.max(max, value);
        }
        return max;
    }

    boolean checkIndex(int index, int size) {
        return (0 <= index && index < size);
    }

    int abs(int a) {
        return Math.abs(a);
    }

    int gcd(int a, int b) {
        if (a * b == 0) return maxInt(a, b);
        else return gcd(minInt(a, b), maxInt(a, b) % minInt(a, b));
    }

    public static void main(String[] args) {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok;

    void run() {
        try {
            long timeStart = System.currentTimeMillis();

            init();
            solve();

            out.close();

            long timeEnd = System.currentTimeMillis();
            System.err.println("time = " + (timeEnd - timeStart) + " compiled");
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }

    }

    String readLine() throws IOException {
        return in.readLine();
    }

    String delimiter = " ";

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            String nextLine = readLine();
            if (null == nextLine)
                return null;

            tok = new StringTokenizer(nextLine);
        }

        return tok.nextToken(delimiter);
    }

    int[] readIntArray(int b) {
        int a[] = new int[b];
        for (int i = 0; i < b; i++) {
            try {
                a[i] = readInt();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return a;
    }

    long[] readLongArray(int b) {
        long a[] = new long[b];
        for (int i = 0; i < b; i++) {
            try {
                a[i] = readLong();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return a;
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    void sortArrayInt(int[] a) {
        Integer arr[] = new Integer[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }
        Arrays.sort(arr);
        for (int i = 0; i < a.length; i++) {
            a[i] = arr[i];
        }
    }

    void sortArrayLong(long[] a) {
        Long arr[] = new Long[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }
        Arrays.sort(arr);
        for (int i = 0; i < a.length; i++) {
            a[i] = arr[i];
        }
    }

}


import java.io.*;
import java.util.*;

public class Main {
    static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    static final int[][] STEPS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    void solve() throws IOException {
        int n = readInt();
        int[] a = readIntArray(n);
        long lAns[][] = new long[n][2];
        long rAns[][] = new long[n][2];
        long rVal = a[0];
        for (int i = 1; i < n; i++) {
            rAns[i][0] = rAns[i - 1][0] + maxLong(0, rVal - a[i] + 1);
            rVal = maxLong(rVal + 1, a[i]);
            rAns[i][1] = rVal;
        }
        long lVal = a[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            lAns[i][0] = lAns[i + 1][0] + maxLong(0, lVal - a[i] + 1);
            lVal = maxLong(lVal + 1, a[i]);
            lAns[i][1] = lVal;
        }
        long answer = minLong(lAns[0][0], rAns[n - 1][0]);
        for (int i = 0; i < n - 1; i++) {
            answer = minLong(answer, rAns[i][0] + lAns[i + 1][0] + (lAns[i + 1][1] == rAns[i][1] ? 1 : 0));
        }
        out.println(answer);

    }

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
        tok = new
                StringTokenizer("");
    }

    int minInt(int... values) {
        int min = Integer.MAX_VALUE;
        for (int value : values) {
            min = Math.min(min, value);
        }
        return min;
    }

    int maxInt(int... values) {
        int max = Integer.MIN_VALUE;
        for (int value : values) {
            max = Math.max(max, value);
        }
        return max;
    }

    long minLong(long... values) {
        long min = Long.MAX_VALUE;
        for (long value : values) {
            min = Math.min(min, value);
        }
        return min;
    }

    long maxLong(long... values) {
        long max = Long.MIN_VALUE;
        for (long value : values) {
            max = Math.max(max, value);
        }
        return max;
    }

    boolean checkIndex(int index, int size) {
        return (0 <= index && index < size);
    }

    int abs(int a) {
        return Math.abs(a);
    }

    int gcd(int a, int b) {
        if (a * b == 0) return maxInt(a, b);
        else return gcd(minInt(a, b), maxInt(a, b) % minInt(a, b));
    }

    public static void main(String[] args) {
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok;

    void run() {
        try {
            long timeStart = System.currentTimeMillis();

            init();
            solve();

            out.close();

            long timeEnd = System.currentTimeMillis();
            System.err.println("time = " + (timeEnd - timeStart) + " compiled");
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }

    }

    String readLine() throws IOException {
        return in.readLine();
    }

    String delimiter = " ";

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            String nextLine = readLine();
            if (null == nextLine)
                return null;

            tok = new StringTokenizer(nextLine);
        }

        return tok.nextToken(delimiter);
    }

    int[] readIntArray(int b) {
        int a[] = new int[b];
        for (int i = 0; i < b; i++) {
            try {
                a[i] = readInt();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return a;
    }

    long[] readLongArray(int b) {
        long a[] = new long[b];
        for (int i = 0; i < b; i++) {
            try {
                a[i] = readLong();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return a;
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    void sortArrayInt(int[] a) {
        Integer arr[] = new Integer[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }
        Arrays.sort(arr);
        for (int i = 0; i < a.length; i++) {
            a[i] = arr[i];
        }
    }

    void sortArrayLong(long[] a) {
        Long arr[] = new Long[a.length];
        for (int i = 0; i < a.length; i++) {
            arr[i] = a[i];
        }
        Arrays.sort(arr);
        for (int i = 0; i < a.length; i++) {
            a[i] = arr[i];
        }
    }

}


import java.io.*;
import java.util.*;

public class Main
{
	private InputStream is;
	private PrintWriter out;
	int time = 0, DP[], start[], end[], dist[], black[], MOD = (int) (1e9 + 7),
			arr[], weight[][], x[], y[], parent[];
	int MAX = 100000, N, K;
	long red[],ans = Long.MAX_VALUE;

	ArrayList<Character>[] amp;
	ArrayList<Pair>[] pmp;
	boolean b[], boo[][];
	Pair prr[];
	HashMap<Pair, Integer> hm = new HashMap();
	long Dp[][][][] = new long[110][110][12][12];

	void soln()
	{
		is = System.in;
		out = new PrintWriter(System.out);
		long s = System.currentTimeMillis();
		solve();

		// out.close();
		out.flush();
		// tr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception
	{
		new Thread(null, new Runnable()
		{
			public void run()
			{
				try
				{
					// new CODEFORCES().soln();
				} catch (Exception e)
				{
					System.out.println(e);
				}
			}
		}, "1", 1 << 26).start();
		new Main().soln();
	}

	int  cost = 0, D[][];
	char ch[], ch1[];
	int hash = 29;
	TreeSet<Cell> ts;
	int x2, y2;
	HashSet<Integer>[] hs = (HashSet<Integer>[]) new HashSet[110];
	void solve()
	{
		int n = ni();
		arr = new int[n+2];
		for(int i = 1;i<=n;i++) arr[i] = ni();
		/*if(n==2){
			if(arr[0]==arr[1]){
				System.out.println(1);
			}
			else System.out.println(0);
			return;
		}
	*/
		long left[] = new long[n+2];
		long right[] = new long[n+2];
		int arr1[] = new int[n+2];
		int arr2[] = new int[n+2];
		for(int i = 1; i <=n ;i++){
			int x = max(arr1[i-1]+1-arr[i],0);
			left[i] = left[i-1]+x;
			arr1[i] =  max(arr1[i-1]+1,arr[i]);
		}
		for(int i = n; i >=1 ;i--){
			int x = max(arr2[i+1]+1-arr[i],0);
			right[i] = right[i+1]+x;
			arr2[i] =  max(arr2[i+1]+1,arr[i]);
		}
		long ans = Long.MAX_VALUE;
		for(int i = 1; i<=n; i++){
		//	System.out.println(left[i]+" "+right[i] +" "+arr1[i]+" "+arr2[i]);
			long val = left[i] + right[i] + max(arr1[i],arr2[i]) - arr[i] + 2*arr[i] - arr1[i]-arr2[i];
			ans = Math.min(ans,val);
		}
		System.out.println(ans);
		//ternary_search(0, n-1);
		/*int p = n-1;
		for(int i = n-1;i>0;i--){
			if(arr[i]>=arr[i-1]){
				p = i;
				break;
			}
		}
		int x = arr[0];
		long fa = 0;
		for(int i = 1; i< p; i++){
			fa+= max(0,x+1-arr[i]);
			x = max(x+1,arr[i]);
		}*/
	}
	void ternary_search(int l,int r)
	{
		//System.out.println(l+" "+r+" "+ans);
	//	for(int i : arr) System.out.print(i+" ");
	//	System.out.println();
	    if(r>=l)
	    {
	        int mid1 = l + (r-l)/3;
	        int mid2 = r -  (r-l)/3;
	        long cnt1 = 0, cnt2 = 0;
	        cnt1 = compute(mid1);
	        cnt2 = compute(mid2);
	       // System.out.println(mid1+" "+ cnt1+" "+mid2+" "+cnt2);
	        ans = Math.min(cnt1,cnt2);
	        if(cnt1<cnt2){
	        	ternary_search(l, mid2-1);
	        }
	        else{
	        	ternary_search(mid1+1, r);
	        }
	    }
	    return;
	}
	long compute(int x){
		long ans = 0;
		int c = arr[0];
		for(int i = 1; i<=x;i++){
			ans += max(c+1-arr[i],0);
			c = max(c+1,arr[i]);
		}
		int temp = arr[x];
		arr[x] = max(c+1,arr[x]);
		//SSystem.out.println(arr[x]+" "+ans);
		c = arr[arr.length-1];
		for(int i = arr.length-1;i>x;i--){
			ans += max(c+1-arr[i-1],0);
			c = max(c+1,arr[i-1]);
		}
		arr[x] = temp;
		return ans;
	}
	public int getParent(int x) {
		while (parent[x] != x) {
			parent[x] = parent[parent[x]];
			x = parent[x];
		}
		return x;
	}
	void getFactors(int n,int x){
		for(int i = 1;i*i<=n;i++){
			if(n%i==0){
				hs[x].add(i);
				hs[x].add(n/i);
			}
		}
	}
	void recur(int a, int b, int k){
		if(k==0){
			if(a==x2 && b==y2) ans++;
			return;
		}
		recur(a,b+1,k-1);
		recur(a,b-1,k-1);
		recur(a+1,b,k-1);
		recur(a-1,b,k-1);
	}
	int min(int a, int b)
	{
		return (a<b)?a:b;
	}
	private class Cell implements Comparable<Cell>
	{
		int u, v, s;
		public Cell(int u, int v, int s)
		{
			this.u = u;
			this.v = v;
			this.s = s;
		}
		public int hashCode()
		{
			return Objects.hash();
		}
		public int compareTo(Cell other)
		{
			return (Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u)))
					&((Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(u, other.v)!=0?Long.compare(u, other.v):Long.compare(v, other.u))));
		}
		public String toString()
		{
			return this.u + " " + this.v;
		}
	}

	class Pair implements Comparable<Pair>
	{
		int u, v, i;

		Pair(int u, int v)
		{
			this.u = u;
			this.v = v;
		}

		Pair(int u, int v, int i)
		{
			this.u = u;
			this.v = v;
			this.i = i;
		}

		public int hashCode()
		{
			return Objects.hash();
		}

		public boolean equals(Object o)
		{
			Pair other = (Pair) o;
			return ((u == other.u && v == other.v));
		}

		public int compareTo(Pair other)
		{
			// return Integer.compare(val, other.val);
			return Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)): (Long.compare(v, other.v));//((Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)): (Long.compare(v, other.v)))
					//&(Long.compare(u, other.v) != 0 ? (Long.compare(u, other.v)): (Long.compare(v, other.u))));
		}

		public String toString()
		{
			return this.u + " " + this.v;
		}
	}

	int max(int a, int b)
	{
		if (a > b)
			return a;
		return b;
	}

	/*public static class FenwickTree
	{

		int[] array; // 1-indexed array, In this array We save cumulative
						// information to perform efficient range queries and
						// updates

		public FenwickTree(int size)
		{
			array = new int[size + 1];
		}

		public int rsq(int ind)
		{
			assert ind > 0;
			int sum = 0;
			while (ind > 0)
			{
				sum += array[ind];
				// Extracting the portion up to the first significant one of the
				// binary representation of 'ind' and decrementing ind by that
				// number
				ind -= ind & (-ind);
			}
			return sum;
		}

		public int rsq(int a, int b)
		{
			assert b >= a && a > 0 && b > 0;
			return rsq(b) - rsq(a - 1);
		}

		public void update(int ind, int value)
		{
			assert ind > 0;
			while (ind < array.length)
			{
				array[ind] += value;
				// Extracting the portion up to the first significant one of the
				// binary representation of 'ind' and incrementing ind by that
				// number
				ind += ind & (-ind);
			}
		}

		public int size()
		{
			return array.length - 1;
		}
	}
*/
	void buildGraph(int n)
	{
		for (int i = 0; i < n; i++)
		{
			int x1 = ni(), y1 = ni(), z = ni();
			pmp[x1].add(new Pair(y1,z));
		}
	}

	long modInverse(long a, long mOD2)
	{
		return power(a, mOD2 - 2, mOD2);
	}

	long power(long x, long y, long m)
	{
		if (y == 0)
			return 1;
		long p = power(x, y / 2, m) % m;
		p = (p * p) % m;

		return (y % 2 == 0) ? p : (x * p) % m;
	}

	public long gcd(long a, long b)
	{
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	static class ST1
	{
		int arr[], st[], size;

		ST1(int a[])
		{
			arr = a.clone();
			size = 10 * arr.length;
			st = new int[size];
			build(0, arr.length - 1, 1);
		}

		void build(int ss, int se, int si)
		{
			if (ss == se)
			{
				st[si] = arr[ss];
				return;
			}
			int mid = (ss + se) / 2;
			int val = 2 * si;
			build(ss, mid, val);
			build(mid + 1, se, val + 1);
			st[si] = Math.min(st[val], st[val + 1]);
		}

		int get(int ss, int se, int l, int r, int si)
		{
			if (l > se || r < ss || l > r)
				return Integer.MAX_VALUE;
			if (l <= ss && r >= se)
				return st[si];
			int mid = (ss + se) / 2;
			int val = 2 * si;
			return Math.min(get(ss, mid, l, r, val),
					get(mid + 1, se, l, r, val + 1));
		}
	}

	static class ST
	{
		int arr[], lazy[], n;

		ST(int a)
		{
			n = a;
			arr = new int[10 * n];
			lazy = new int[10 * n];
		}

		void up(int l, int r, int val)
		{
			update(0, n - 1, 0, l, r, val);
		}

		void update(int l, int r, int c, int x, int y, int val)
		{
			if (lazy[c] != 0) {
				lazy[2 * c + 1] += lazy[c];
				lazy[2 * c + 2] += lazy[c];
				if (l == r)
					arr[c] += lazy[c];
				lazy[c] = 0;
			}
			if (l > r || x > y || l > y || x > r)
				return;
			if (x <= l && y >= r)

			{
				lazy[c] += val;
				return;
			}
			int mid = l + r >> 1;
			update(l, mid, 2 * c + 1, x, y, val);
			update(mid + 1, r, 2 * c + 2, x, y, val);
			arr[c] = Math.max(arr[2 * c + 1], arr[2 * c + 2]);
		}

		int an(int ind)
		{
			return ans(0, n - 1, 0, ind);
		}

		int ans(int l, int r, int c, int ind)
		{
			if (lazy[c] != 0)
			{
				lazy[2 * c + 1] += lazy[c];
				lazy[2 * c + 2] += lazy[c];
				if (l == r)
					arr[c] += lazy[c];
				lazy[c] = 0;
			}
			if (l == r)
				return arr[c];
			int mid = l + r >> 1;
			if (mid >= ind)
				return ans(l, mid, 2 * c + 1, ind);
			return ans(mid + 1, r, 2 * c + 2, ind);
		}
	}

	public static int[] shuffle(int[] a, Random gen)
	{
		for (int i = 0, n = a.length; i < n; i++)
		{
			int ind = gen.nextInt(n - i) + i;
			int d = a[i];
			a[i] = a[ind];
			a[ind] = d;
		}
		return a;
	}

	long power(long x, long y, int mod)
	{
		long ans = 1;
		while (y > 0)
		{
			if (y % 2 == 0)
			{
				x = (x * x) % mod;
				y /= 2;
			} else
			{
				ans = (x * ans) % mod;
				y--;
			}
		}
		return ans;
	}

	// To Get Input
	// Some Buffer Methods
	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{
				lenbuf = is.read(inbuf);
			} catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c)
	{
		return !(c >= 33 && c <= 126);
	}

	private int skip()
	{
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	private double nd()
	{
		return Double.parseDouble(ns());
	}

	private char nc()
	{
		return (char) skip();
	}

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b)))
		{ // when nextLine, (isSpaceChar(b) && b != '
									// ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b)))
		{
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			} else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			} else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	private void tr(Object... o)
	{
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}
}