Codeforces 591C Median Smoothing【思维】

最新推荐文章于 2020-04-15 10:10:39 发布

原创最新推荐文章于 2020-04-15 10:10:39 发布 · 406 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Codeforces 591C

思维专栏收录该内容

692 篇文章

订阅专栏

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.

Input

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.

Output

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.

Examples

input
4
0 0 1 1

output
0
0 0 1 1

input
5
0 1 0 1 0

output
2
0 0 0 0 0

Note

In the second sample the stabilization occurs in two steps: $\text{[math]}$ , 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");
    }
}