A schoolboy named Vasya loves reading books on programming and mathematics. He has recently read an encyclopedia article that described the method of median smoothing (or median filter) and its many applications in science and engineering. Vasya liked the idea of the method very much, and he decided to try it in practice.
Applying the simplest variant of median smoothing to the sequence of numbers a1, a2, ..., an will result a new sequence b1, b2, ..., bnobtained by the following algorithm:
- b1 = a1, bn = an, that is, the first and the last number of the new sequence match the corresponding numbers of the original sequence.
- For i = 2, ..., n - 1 value bi is equal to the median of three values ai - 1, ai and ai + 1.
The median of a set of three numbers is the number that goes on the second place, when these three numbers are written in the non-decreasing order. For example, the median of the set 5, 1, 2 is number 2, and the median of set 1, 0, 1 is equal to 1.
In order to make the task easier, Vasya decided to apply the method to sequences consisting of zeros and ones only.
Having made the procedure once, Vasya looked at the resulting sequence and thought: what if I apply the algorithm to it once again, and then apply it to the next result, and so on? Vasya tried a couple of examples and found out that after some number of median smoothing algorithm applications the sequence can stop changing. We say that the sequence is stable, if it does not change when the median smoothing is applied to it.
Now Vasya wonders, whether the sequence always eventually becomes stable. He asks you to write a program that, given a sequence of zeros and ones, will determine whether it ever becomes stable. Moreover, if it ever becomes stable, then you should determine what will it look like and how many times one needs to apply the median smoothing algorithm to initial sequence in order to obtain a stable one.
The first input line of the input contains a single integer n (3 ≤ n ≤ 500 000) — the length of the initial sequence.
The next line contains n integers a1, a2, ..., an (ai = 0 or ai = 1), giving the initial sequence itself.
If the sequence will never become stable, print a single number - 1.
Otherwise, first print a single integer — the minimum number of times one needs to apply the median smoothing algorithm to the initial sequence before it becomes is stable. In the second line print n numbers separated by a space — the resulting sequence itself.
4 0 0 1 1
0 0 0 1 1
5 0 1 0 1 0
2 0 0 0 0 0
In the second sample the stabilization occurs in two steps: 
,
and the sequence 00000 is obviously stable.
現在給出一個長度爲N的一個01序列，每一輪遊戲從左到右去改變值，第一個位子和最後一個位子上的數不會改變，其他位子的數，變成a【i】，a【i-1】，a【i+1】三個數中出現最多的那個數。問進行多少輪遊戲能夠不動 ，如果可以 ，輸出遊戲輪次以及最終序列的樣子，否則輸出-1.
思路：
①通過手寫幾種樣例我們不難發現，結果是不存在-1的，換句話說，就是一定有解。
②根據觀察我們也不難發現，只有01間隔的子串纔會進行變化，對於一堆連在一起的0或者1來講，其整個過程都不會進行改變。
那麼我們很容易手寫出幾種情況：
長度爲偶數：
1. 0101--->0011步數爲1
2. 1010--->1100步數爲1
長度爲奇數：
3. 01010--->00000步數爲2
4. 10101--->11111步數爲2
③那麼我們對於整個序列，只要找01間隔的最長的序列就能夠確定遊戲的輪次。Ans=Max(（Len-1）/2)；
然後對於每個間隔子串，進行處理即可。
Ac代碼：
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int step;
int a[500500];
int ans[500500];
void Slove(int ss,int ee)
{
if(ee-ss+1==2)
{
ans[ss]=a[ss];
ans[ee]=a[ee];
return ;
}
step=max(step,((ee-ss+1)-1)/2);
if((ee-ss+1)%2==0)
{
for(int j=ss;j<=(ss+ee)/2;j++)ans[j]=0;
for(int j=(ss+ee)/2+1;j<=ee;j++)ans[j]=1;
if(a[ss]==1)for(int j=ss;j<=ee;j++)ans[j]=1-ans[j];
}
else
{
for(int j=ss;j<=ee;j++)ans[j]=0;
if(a[ss]==1)for(int j=ss;j<=ee;j++)ans[j]=1-ans[j];
}
}
int main()
{
int n;
while(~scanf("%d",&n))
{
step=0;
for(int i=1;i<=n;i++)scanf("%d",&a[i]);
ans[1]=a[1],ans[n]=a[n];
for(int i=1;i<n;i++)
{
if(a[i]==a[i+1])
{
ans[i]=a[i];
continue;
}
else
{
int ss=i;
int ee=i+1;
while(ee<n&&a[ee]!=a[ee+1])ee++;
Slove(ss,ee);
i=ee;
}
}
printf("%d\n",step);
for(int i=1;i<=n;i++)
{
printf("%d ",ans[i]);
}
printf("\n");
}
}