A. Almost Arithmetic Progression
time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Polycarp likes arithmetic progressions. A sequence [a1,a2,…,an] is called an arithmetic progression if for each i (1≤i<n) the value ai+1−ai is the same. For example, the sequences [42], [5,5,5], [2,11,20,29] and [3,2,1,0] are arithmetic progressions, but [1,0,1], [1,3,9] and [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]. 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 1, an element can be increased by 1, an element can be left unchanged.
Determine a minimum possible number of elements in b which can be changed (by exactly one), so that the sequence b becomes an arithmetic progression, or report that it is impossible.
It is possible that the resulting sequence contains element equals 0.
Input
The first line contains a single integer n (1≤n≤100000) — the number of elements in b.
The second line contains a sequence b1,b2,…,bn (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
inputCopy
4
24 21 14 10
outputCopy
3
inputCopy
2
500 500
outputCopy
0
inputCopy
3
14 5 1
outputCopy
-1
inputCopy
5
1 3 6 9 12
outputCopy
1
Note
In the first example Polycarp should increase the first number on 1, decrease the second number on 1, increase the third number on 1, and the fourth number should left unchanged. So, after Polycarp changed three elements by one, his sequence became equals to [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], which is an arithmetic progression.
思路：
通過調整前兩個數，求得公差，依次對後面數操作，滿足公差要求，若能一直操作結束，則滿足題意，注意，需要在9次調整中選最小的，9次調整，可以通過循環得到。
package 一月十三;
import java.util.Scanner;
public class almostArithmeticprogressoon {
private static final int maxn=100005;
public static void main(String[] args) {
// TODO Auto-generated method stub
int n,i,j,k;
int[] a=new int[maxn];
int[] b=new int[maxn];
Scanner sc=new Scanner(System.in);
n=sc.nextInt();
for ( i = 1; i <=n; i++) {
a[i]=sc.nextInt();
}
sc.close();
//一個或兩個數直接返回
if(n==2||n==1) {
System.out.println(0);
return;
}
//最小值不會大於n
int minum=n;
//如果n==0，返回-1；否則返回minum;
int flag=0;
//暴力求解，外層循環i,代表對第一個元素的操作；
for(i=-1;i<=1;i++) {
//代表對第二元素操作，外循環三次，內循環三次，總共3*3次；
for(j=-1;j<=1;j++) {
//cnt代表對前兩個元素的操作數量，i，j==1或-1；均進行1次，0進行次；
int cnt=Math.abs(i)+Math.abs(j);
//複製數組位b，對操作，因爲要對a 操作9次，必須保證a不被修改
for(k=0;k<=n;k++) {
b[k]=a[k];
}
//對b 進行操作，在i，j取不同值
b[1]+=i;
b[2]+=j;
//x代表差值
int x=b[1]-b[2];
//從第三項與第二項差開始，一直到最後兩項的差值；
for(k=2;k<n;k++) {
//如果前一項減去後一項加1後等於x;對x進行加1操作
if(b[k]-(b[k+1]+1)==x) {
b[k+1]+=1;
cnt++;
}
else if(b[k]-b[k+1]==x) {
}
else if(b[k]-(b[k+1]-1)==x) {
b[k+1]-=1;
cnt++;
}
//+，-不變都不滿足，進行結束for循環
else {
break;
}
}
//循環結束後，判斷，如果k==n,則未執行break;說明滿足題意### 注意，是n 不是n-1; 因爲最後一次會加1；
//若能達到n ，flag置爲1；
if(k==n) {
minum=Math.min(minum,cnt);flag=1;
}
}
}
//若爲1，則存在，輸出，否則爲0；
//當n ==1||n==2時，已經在前面結束程序
if(flag==1) {
System.out.println(minum);
}
else System.out.println(-1);
}
}