RMQ CF Approximating a Constant Range 区间最大最小值问题

B. Approximating a Constant Range

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

When Xellos was doing a practice course in university, he once had to measure the intensity of an effect that slowly approached equilibrium. A good way to determine the equilibrium intensity would be choosing a sufficiently large number of consecutive data points that seems as constant as possible and taking their average. Of course, with the usual sizes of data, it's nothing challenging — but why not make a similar programming contest problem while we're at it?

You're given a sequence of n data points a1, ..., an. There aren't any big jumps between consecutive data points — for each 1 ≤ i < n, it's guaranteed that |ai + 1 - ai| ≤ 1.

A range [l, r] of data points is said to be almost constant if the difference between the largest and the smallest value in that range is at most 1. Formally, let M be the maximum and m the minimum value of ai for l ≤ i ≤ r; the range [l, r] is almost constant if M - m ≤ 1.

Find the length of the longest almost constant range.

Input

The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of data points.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000).

Output

Print a single number — the maximum length of an almost constant range of the given sequence.

Sample test(s)

input

5
1 2 3 3 2

output

4

input

11
5 4 5 5 6 7 8 8 8 7 6

output

</pre></div><pre style="margin-top: 0px; margin-bottom: 0px; padding: 0.25em; font-size: 12.6000003814697px; font-family: Consolas, 'Lucida Console', 'Andale Mono', 'Bitstream Vera Sans Mono', 'Courier New', Courier; line-height: 1.25em; white-space: pre-wrap; word-wrap: break-word; color: rgb(136, 0, 0); background-color: rgb(239, 239, 239);">5

Note

In the first sample, the longest almost constant range is [2, 5]; its length (the number of data points in it) is 4.

In the second sample, there are three almost constant ranges of length 4: [1, 4], [6, 9] and [7, 10]; the only almost constant range of the maximum length 5 is [6, 10].

#include <iostream>
#include<stdio.h>
using namespace std;
int maxx[100005][20];
int minn[100005][20];
int a[100005];
#include<stdlib.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<map>
int suanmax(int l,int r)
{
    int k=(int)(log((double)(r-l+1))/log(2.0));
    return max(maxx[l][k],maxx[r-(1<<k)+1][k]);
}
int suanmin(int l,int r)
{
    int k=(int)(log((double)(r-l+1))/log(2.0));
    return min(minn[l][k],minn[r-(1<<k)+1][k]);
}
int   main()
{
    int n;
    while(scanf("%d",&n)!=eof)
    {
        int i;
        for(i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
            minn[i][0]=a[i];
            maxx[i][0]=a[i];
        }
        int j;
        int k;
        for(j=1; (1<<j)<=n; j++)
        {
            for(k=0; k+(1<<j)-1<=n; k++)
            {
                minn[k][j]=min(minn[k][j-1],minn[k+(1<<(j-1))][j-1]);
                maxx[k][j]=max(maxx[k][j-1],maxx[k+(1<<(j-1))][j-1]);
            }
        }
        int ans=0;
        int p=1;
        for(i=1; i<=n; i++)
        {
            while(suanmax(p,i)-suanmin(p,i)>1&&p<=i)
            {
                p++;
            }
            ans=max(ans,i-p+1);
        }
        printf("%d\n",ans);
    }

}