/*************************************************************************}
{*                                                                       *}
{*                              XIV OI                                   *}
{*                                                                       *}
{*   Zadanie: Drzewa (DRZ)                                               *}
{*   Plik:    drz.cpp                                                    *}
{*   Autor:   Jakub Radoszewski                                          *}
{*   Opis:    Rozwiązanie autorskie, Złożoność czasowa: O(n logn),       *}
{*            Złożoność pamięciowa: O(n)                                 *}
{*                                                                       *}
{*************************************************************************/
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <utility>
using namespace std;


#define MAX_N 50000
#define NIESK 1000000000 /* nieskończoność */
#define ROOT 0 /* numer korzenia w dowolnym spośród drzew mintree */


struct node
/* Wierzchołek drzewa mintree. */
{
  int lsyn, psyn; /* numer lewego i prawego syna */
  int lewy, prawy; /* wierzchołek reprezentuje przedział [lewy, prawy] */
  int wart;
}; /* node */

/* Tablica drzew mintree:
 * 0 - A1, 1 - A2, 2 - A3, 3 - B1, 4 - B2, 5 - B3, 6 - C1, 7 - C2, 8 - C3 */
node mintree[9][2 * MAX_N];

int n, i;
int h[MAX_N];
/* Najmniejszy współczynnik nieporządku dla zamian danego drzewa. */
long long wyn[MAX_N],
  wspol, /* Początkowy współczynnik nieporządku. */
  akt; /* Właśnie liczony współczynnik nieporządku. */

/* Tablica dl (drzewo-liczba) reprezentuje funkcję, która pobiera numer
 * drzewa (między 0 a n-1) i zwraca jego wysokość po przenumerowaniu
 * (także pomiędzy 0 a n-1).
 * Tablica ld (liczba-drzewo) jest odwróceniem poprzedniej funkcji.
 * Obie tablice są wyliczane w procedurze przenumeruj. */
int dl[MAX_N], ld[MAX_N];



/*****************************************************************************/
/* Implementacja operacji na drzewach mintree                                */
/*****************************************************************************/

int akt_poz[9]; /* aktualne pozycje wierzchołków tworzonych w drzewach
                   mintree 0-8 */


int create(int ndrz, int l, int p)
/* Ta funkcja tworzy wierzchołek odpowiadający przedziałowi [l, p] w drzewie
 * mintree o numerze ndrz. */
{
  int sr = (l + p) / 2, v = akt_poz[ndrz]++;
  mintree[ndrz][v].lewy = l; mintree[ndrz][v].prawy = p;
  mintree[ndrz][v].wart = NIESK;
  if (l == p)
    return v;
  mintree[ndrz][v].lsyn = create(ndrz, l, sr);
  mintree[ndrz][v].psyn = create(ndrz, sr + 1, p);
  return v;
} /* create */

void build()
/* Ta procedura buduje wszystkie drzewa mintree. */
{
  for (int nr = 0; nr < 9; nr++)
    akt_poz[nr] = 0;
  for (int nr = 0; nr < 9; nr++)
    create(nr, 0, n - 1);
} /* build */

void insert(int ndrz, int wierzch, int klucz, int wart)
/* Ta procedura wstawia element charakteryzowany przez parę (klucz,wart)
 * do drzewa mintree o numerze ndrz; wierzch to aktualnie rozważany wierzchołek
 * drzewa. */
{
  mintree[ndrz][wierzch].wart = min(mintree[ndrz][wierzch].wart, wart);
  int l = mintree[ndrz][wierzch].lewy, p = mintree[ndrz][wierzch].prawy;
  if (l < p)
  {
    int sr = (l + p) / 2;
    if (klucz <= sr)
      insert(ndrz, mintree[ndrz][wierzch].lsyn, klucz, wart);
    else
      insert(ndrz, mintree[ndrz][wierzch].psyn, klucz, wart);
  } /* if */
} /* insert */

void del(int ndrz, int wierzch, int klucz)
/* Ta procedura usuwa element o danym kluczu z drzewa mintree o numerze
 * ndrz; wierzch to aktualnie rozważany wierzchołek drzewa. */
{
  int l = mintree[ndrz][wierzch].lewy, p = mintree[ndrz][wierzch].prawy;
  if (l == p)
  {
    mintree[ndrz][wierzch].wart = NIESK;
    return;
  } /* if */
  int sr = (l + p) / 2;
  if (klucz <= sr)
    del(ndrz, mintree[ndrz][wierzch].lsyn, klucz);
  else
    del(ndrz, mintree[ndrz][wierzch].psyn, klucz);
  mintree[ndrz][wierzch].wart = 
    min(mintree[ndrz][mintree[ndrz][wierzch].lsyn].wart,
        mintree[ndrz][mintree[ndrz][wierzch].psyn].wart);    
} /* del */

int min_val(int ndrz, int wierzch, int lewy, int prawy)
/* Ta funkcja wykonuje operację "min_val" na drzewie mintree o numerze
 * ndrz dla przedziału I=[lewy,prawy] i wierzchołka v=wierzch. */
{
  if (lewy > prawy)
    return NIESK;
  int l = mintree[ndrz][wierzch].lewy, p = mintree[ndrz][wierzch].prawy;
  if (lewy <= l && p <= prawy)
    return mintree[ndrz][wierzch].wart;
  int sr = (l + p) / 2;
  if (lewy > sr)
    return min_val(ndrz, mintree[ndrz][wierzch].psyn, lewy, prawy);
  if (prawy <= sr)
    return min_val(ndrz, mintree[ndrz][wierzch].lsyn, lewy, prawy);
  return min(min_val(ndrz, mintree[ndrz][wierzch].lsyn, lewy, prawy),
             min_val(ndrz, mintree[ndrz][wierzch].psyn, lewy, prawy));
} /* min_val */

/*****************************************************************************/
/* Koniec implementacji operacji na drzewach mintree                         */
/*****************************************************************************/

pair<int, int> tmp[MAX_N]; /* pomocnicza tablica używana do sortowania drzew */

void przenumeruj()
/* Ta procedura oblicza tablice dl i ld. Tablica par (wysokość drzewa,drzewo)
 * zostaje posortowana w kolejności niemalejących wysokości. */
{
  for (int i = 0; i < n; i++)
    tmp[i] = make_pair(h[i], i);
  sort(tmp, tmp + n);
  for (int i = 0; i < n; i++)
  {
    dl[tmp[i].second] = i;
    ld[i] = tmp[i].second;
  } /* for */
} /* przenumeruj */


void licz_wspol()
/* Ta procedura liczy początkowy współczynnik nieporządku. */
{
  wspol = 0LL;
  for (int i = 0; i < n - 1; i++)
    wspol += abs(h[i] - h[i + 1]);
} /* licz_wspol */



int f1(int a, int b, int h)
{
  return -abs(a - h) - abs(h - b) + a + b;
} /* f1 */

int f2(int a, int b, int h)
{
  return -abs(a - h) - abs(h - b) - a + b;
} /* f2 */

int f3(int a, int b, int h)
{
  return -abs(a - h) - abs(h - b) - a - b;
} /* f3 */

int min(int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8)
/* Minimum z 9 wartości, potrzebne w głównej pętli. */
{
  return min(min(min(a0,a1),min(a2,a3)),min(min(a4,a5),min(min(a6,a7),a8)));
} /* min */

void dod_A(int i)
/* Ta procedura wstawia i-te drzewo do drzew mintree: A1, A2 i A3,
 * przypisując mu wartość równą sumie wartości z drzewa mintree A i
 * odpowiedniego drzewa mintree Ti. */
{  
  int a = min(h[i - 1], h[i + 1]);
  int b = max(h[i - 1], h[i + 1]);
  insert(0, ROOT, dl[i], -2 * h[i] + f1(a, b, h[i]));
  insert(1, ROOT, dl[i], f1(a, b, h[i]));
  insert(2, ROOT, dl[i], 2 * h[i] + f1(a, b, h[i]));
} /* dod_A */

void dod_B(int i)
/* Ta procedura wstawia i-te drzewo do drzew mintree: B1, B2 i B3,
 * przypisując mu wartość równą sumie wartości z drzewa mintree B i
 * odpowiedniego drzewa mintree Ti. */
{  
  int a = min(h[i - 1], h[i + 1]);
  int b = max(h[i - 1], h[i + 1]);
  insert(3, ROOT, dl[i], -2 * h[i] + f2(a, b, h[i]));
  insert(4, ROOT, dl[i], f2(a, b, h[i]));
  insert(5, ROOT, dl[i], 2 * h[i] + f2(a, b, h[i]));
} /* dod_B */
 
void dod_C(int i)
/* Ta procedura wstawia i-te drzewo do drzew mintree: C1, C2 i C3,
 * przypisując mu wartość równą sumie wartości z drzewa mintree C i
 * odpowiedniego drzewa mintree Ti. */
{  
  int a = min(h[i - 1], h[i + 1]);
  int b = max(h[i - 1], h[i + 1]);
  insert(6, ROOT, dl[i], -2 * h[i] + f3(a, b, h[i]));
  insert(7, ROOT, dl[i], f3(a, b, h[i]));
  insert(8, ROOT, dl[i], 2 * h[i] + f3(a, b, h[i]));
} /* dod_C */

/*****************************************************************************/
/* Rozważanie przypadków szczególnych                                        */
/*****************************************************************************/

int zm_wart(int wys, int poz)
/* Ta funkcja liczy zmianę wartości współczynnika nieporządku, kiedy drzewo
 * o wysokości wys zostaje umiejscowione na pozycji poz. */
{
  int wyn = 0;
  if (poz > 0)
    wyn += abs(wys - h[poz - 1]);
  if (poz < n - 1)
    wyn += abs(wys - h[poz + 1]);
  return wyn;
} /* zm_wart */

int zm_wart1(int poz)
/* Ta funkcja liczy zmianę wartości współczynnika nieporządku, kiedy drzewa
 * na pozycjach poz i poz+1 zostają zamienione miejscami. */
{
  int wyn = 0;
  if (poz > 0)
    wyn -= abs(h[poz] - h[poz - 1]) - abs(h[poz + 1] - h[poz - 1]);
  if (poz + 1 < n - 1)
    wyn -= abs(h[poz + 2] - h[poz + 1]) - abs(h[poz + 2] - h[poz]);
  return wyn;
} /* zm_wart1 */


void przypadki_szczegolne()
/* Rozważenie wszystkich przypadków szczególnych (w łącznym czasie O(n)). */
{
  long long pwyn;
  
  /* Drzewo zerowe */
  for (i = 2; i < n; i++)
  {
    pwyn = wspol - zm_wart(h[0], 0) - zm_wart(h[i], i)
                 + zm_wart(h[0], i) + zm_wart(h[i], 0);
    wyn[0] = min(wyn[0], pwyn);
    wyn[i] = min(wyn[i], pwyn);
  } /* for */
  
  /* Drzewo (n-1)-wsze */
  for (i = 0; i < n - 2; i++)
  {
    pwyn = wspol - zm_wart(h[n - 1], n - 1) - zm_wart(h[i], i)
                 + zm_wart(h[n - 1], i) + zm_wart(h[i], n - 1);
    wyn[n - 1] = min(wyn[n - 1], pwyn);
    wyn[i] = min(wyn[i], pwyn);
  } /* for */
  
  /* Pary drzew sąsiednich */
  for (i = 0; i < n - 1; i++)
  {
    pwyn = wspol + zm_wart1(i);
    wyn[i] = min(wyn[i], pwyn);
    wyn[i + 1] = min(wyn[i + 1], pwyn);
  } /* for */
} /* przypadki_szczegolne */

/*****************************************************************************/
/* Koniec rozważania przypadków szczególnych                                 */
/*****************************************************************************/


int main()
{
  scanf("%d",&n);
  for (i = 0; i < n; i++)
    scanf("%d", &h[i]);
  build();
  przenumeruj();
  licz_wspol();
  for (i = 0; i < n; i++)
    wyn[i] = wspol;
  /* Dodajemy wszystkie drzewa do A1, A2 oraz A3. */
  for (i = 0; i < n; i++)
    if (ld[i] > 0 && ld[i] < n - 1)
      dod_A(ld[i]);
  for (i = 0; i < n; i++) /* rozważamy i-te drzewo */
  {
    /* usuwamy sąsiadów i-tego drzewa */
    for (int j = 0; j < 9; j++)
    {
      if (ld[i] > 1) /* sąsiad nie jest wyjątkiem */
        del(j, ROOT, dl[ld[i] - 1]);
      if (ld[i] < n - 2) /* sąsiad nie jest wyjątkiem */
        del(j, ROOT, dl[ld[i] + 1]);
    } /* for */

    if (ld[i] > 0 && ld[i] < n - 1)
    /* Ten fragment nie jest wykonywany dla skrajnie lewego oraz skrajnie
     * prawego drzewa. */
    {
      /* wyliczamy minimalny współczynnik */
      int a = min(h[ld[i] - 1], h[ld[i] + 1]);
      int b = max(h[ld[i] - 1], h[ld[i] + 1]);
      int A, B, H = h[ld[i]]; // A=f(a), B=f(b)
      if (a == h[ld[i] - 1])
      {
        A = dl[ld[i] - 1]; B = dl[ld[i] + 1];
      } /* if */
      else
      {
        A = dl[ld[i] + 1]; B = dl[ld[i] - 1];
      } /* else */
      akt = wspol +
        min(f1(a, b, H) - 2 * H + min_val(0, ROOT, 0, A - 1),
            f2(a, b, H) - 2 * H + min_val(1, ROOT, A, B),
            f3(a, b, H) - 2 * H + min_val(2, ROOT, B + 1 , n - 1),
            f1(a, b, H) + min_val(3, ROOT, 0, A - 1),
            f2(a, b, H) + min_val(4, ROOT, A, B),
            f3(a, b, H) + min_val(5, ROOT, B + 1, n - 1),
            f1(a, b, H) + 2 * H + min_val(6, ROOT, 0, A - 1),
            f2(a, b, H) + 2 * H + min_val(7, ROOT, A, B),
            f3(a, b, H) + 2 * H + min_val(8, ROOT, B + 1, n - 1));
      wyn[ld[i]] = akt;
    } /* if */
    
    /* Wstawienie sąsiadów z powrotem do odpowiednich drzew mintree -
     * równocześnie aktualizujemy drzewa mintree. */
    if (ld[i] > 1) /* sąsiad nie jest wyjątkiem */
    {
      if (dl[ld[i] - 2] > i)
        dod_B(ld[i] - 1);
      else
        dod_C(ld[i] - 1);
    } /* if */
    if (ld[i] < n - 2) /* sąsiad nie jest wyjątkiem */
    {
      if (dl[ld[i] + 2] > i)
        dod_B(ld[i] + 1);
      else
        dod_C(ld[i] + 1);
    } /* if */
  } /* for */
  przypadki_szczegolne();
  for (i = 0; i < n; i++)
    printf("%lld\n", wyn[i]);
  return 0;
} /* main */
