# Codeforces978D. Almost Arithmetic Progression （暴力）

D. Almost Arithmetic Progression

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Polycarp likes arithmetic progressions. A sequence [a1,a2,…,an][a1,a2,…,an] is called an arithmetic progression if for each ii (1≤i<n1≤i<n) the value ai+1−aiai+1−ai is the same. For example, the sequences , [5,5,5][5,5,5], [2,11,20,29][2,11,20,29] and [3,2,1,0][3,2,1,0] are arithmetic progressions, but [1,0,1][1,0,1], [1,3,9][1,3,9] and [2,3,1][2,3,1] are not.

It follows from the definition that any sequence of length one or two is an arithmetic progression.

Polycarp found some sequence of positive integers [b1,b2,…,bn][b1,b2,…,bn]. He agrees to change each element by at most one. In the other words, for each element there are exactly three options: an element can be decreased by 11, an element can be increased by 11, an element can be left unchanged.

Determine a minimum possible number of elements in bb which can be changed (by exactly one), so that the sequence bb becomes an arithmetic progression, or report that it is impossible.

It is possible that the resulting sequence contains element equals 00.

Input

The first line contains a single integer nn (1≤n≤100000)(1≤n≤100000) — the number of elements in bb.

The second line contains a sequence b1,b2,…,bnb1,b2,…,bn (1≤bi≤109)(1≤bi≤109).

Output

If it is impossible to make an arithmetic progression with described operations, print -1. In the other case, print non-negative integer — the minimum number of elements to change to make the given sequence becomes an arithmetic progression. The only allowed operation is to add/to subtract one from an element (can't use operation twice to the same position).

Examples

input

Copy

4
24 21 14 10


output

Copy

3


input

Copy

2
500 500


output

Copy

0


input

Copy

3
14 5 1


output

Copy

-1


input

Copy

5
1 3 6 9 12


output

Copy

1


Note

In the first example Polycarp should increase the first number on 11, decrease the second number on 11, increase the third number on 11, and the fourth number should left unchanged. So, after Polycarp changed three elements by one, his sequence became equals to [25,20,15,10][25,20,15,10], which is an arithmetic progression.

In the second example Polycarp should not change anything, because his sequence is an arithmetic progression.

In the third example it is impossible to make an arithmetic progression.

In the fourth example Polycarp should change only the first element, he should decrease it on one. After that his sequence will looks like [0,3,6,9,12][0,3,6,9,12], which is an arithmetic progression.

判断给出的一组数能否在给定的三种操作下（+1、-1、不变）变成等差数列，若能则输出最小改变次数，若不行则输出-1。

一开始一直在想DFS的方法怎么处理，写到中途突然发现直接暴力处理就可以了。

若这堆数可以变成等差数列，则他们每一项的差必定为（a[i]-a）/(n-1)。a[i]和a分别可以做+1、-1、不变的操作。所以实际上就是暴力的跑9个判断，然后取其中修改次数最小的值。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<stack>
using namespace std;
const int inf=0x3f3f3f3f;

int n;
int a,b;
bool vis;
int work(int d,int tcnt)
{
bool tag=true;
d=d/(n-1);
for(int i=2;i<=n;i++)
{
if(b[i]-b[i-1]==d+1)
{
b[i]--;
tcnt++;
}
else if(b[i]-b[i-1]==d-1)
{
b[i]++;
tcnt++;
}
else if(b[i]-b[i-1]==d)
continue;
else
{
tag=false;
break;
}
}
for(int i=1;i<=n;i++)
b[i]=a[i];
if(tag)
return tcnt;
else
return inf;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
b[i]=a[i];
}
if(n==1||n==2){
printf("0\n");
return 0;
}
int ans=inf;
for(int i=-1;i<=1;i++)
{
for(int j=-1;j<=1;j++)
{
int d=(a[n]+i)-(a+j);
if(d%(n-1)==0)
{
b[n]=a[n]+i;
b=a+j;
ans=min(work(d,abs(i)+abs(j)),ans);
}
}
}

if(ans==inf)
printf("-1\n");
else
cout<<ans<<endl;
getchar();
getchar();
}