CodeForces 610B-Vika and Squares，有坑点，不是很难~~

B. Vika and Squares

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Vika has n jars with paints of distinct colors. All the jars are numbered from 1 to n and
the i-th jar contains ai liters
of paint of color i.

Vika also has an infinitely long rectangular piece of paper of width 1, consisting of squares of size 1 × 1.
Squares are numbered 1, 2, 3and
so on. Vika decided that she will start painting squares one by one from left to right, starting from the square number 1 and some arbitrary
color. If the square was painted in color x, then the next square will be painted in color x + 1.
In case of x = n, next square is painted in color 1.
If there is no more paint of the color Vika wants to use now, then she stops.

Square is always painted in only one color, and it takes exactly 1 liter of paint. Your task is to calculate the maximum number of squares that
might be painted, if Vika chooses right color to paint the first square.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) —
the number of jars with colors Vika has.

The second line of the input contains a sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109),
where ai is
equal to the number of liters of paint in the i-th jar, i.e. the number of liters of color i that
Vika has.

Output

The only line of the output should contain a single integer — the maximum number of squares that Vika can paint if she follows the rules described above.

Examples

input

5
2 4 2 3 3

output

12

input

3
5 5 5

output

15

input

6
10 10 10 1 10 10

output

11

Note

In the first sample the best strategy is to start painting using color 4. Then the squares will be painted in the following colors (from left
to right): 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5.

In the second sample Vika can start to paint using any color.

In the third sample Vika should start painting using color number 5.

我也是实在无聊，积累了好多题没做完还拉比赛做，而且结果惨不能睹，除了两道做过的抢了一血，别的一个都不会；

先来说说这个题吧，快结束的时候有点思路，但不知道正确与否，第二天逃课WA了三遍才A出来，不得不说，CF的后台测试数据真的好强大啊，第一次WA在第五组，如果只有一个元素直接输出，而我输出”1“，然后两次WA在第7组，但我知道了我开始的思路是有问题的，我一直以为是从最后一个最小的元素后一位开始，但是举了一组测试样例没过，然后才发现其实不是从最后或者前面开始，而是从相邻两个最小元素的距离最大值开始（这里的情况是针对最小值有多个的情况，而如果最小值只有一个设为X,那么答案就是(X*（n+1）-1)~~想想看，第三组样例应该可以说明），第七组我才发现会超int
，所以要用 long long;

如果没明白我说的，请看这组样例；

6

2 1 1 3 2 1      输出为8,也就是说从3开始循环一遍，

同样的；

7

5 2 2 3 4 2 6   输出为16，从3或者6开始循环两遍；

明白了吧，答案就是用最小的乘以个数，最小的表明最多循环几遍，而相邻最下元素的距离最大值表明从哪里开始循环；

以上题意略，主要是列举的情况，其实冷静思考并不难；

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const int N=200000+10;
int a[N],b[N];
int main()
{
    long long n,i;
    while(~scanf("%I64d",&n))
    {
        memset(b,0,sizeof(b));
        for(i=1; i<=n; i++)
        {
            scanf("%d",&a[i]);
            b[i]=a[i];
        }
        if(n==1)
            printf("%d\n",a[1]);
        else
        {
            sort(b+1,b+n+1);
            if(b[1]!=b[2])
            {
                printf("%I64d\n",(b[1]+1)*n-1);
            }
            else
            {
                if(b[1]==b[n])
                    printf("%I64d\n",b[1]*n);
                else
                {
                    int x=1000000000;
                    int k2=0;
                    for(i=n; i>0; i--)
                        if(a[i]<x)
                        {
                            x=a[i],k2=i;
                        }
                    x=1000000000;
                    int k1=0;
                    for(i=1; i<=n; i++)
                        if(a[i]<x)
                        {
                            x=a[i],k1=i;
                        }
                    long long maxx=n-k2+k1-1;
                    for(i=k1+1; i<=n; i++)
                    {
                        if(b[1]==a[i])
                        {
                            maxx=max(i-k1-1,maxx);
                            k1=i;
                        }
                    }
                    printf("%I64d\n",n*b[1]+maxx);
                }
            }
        }
    }
    return 0;
}