Coderforces 354Div2

A. Nicholas and Permutation

time limit per test:1 second	memory limit per test:256 megabytes

Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.

Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.

Input

The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.

The second line of the input contains n distinct integers a1, a2, …, an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.

Output

Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.

Examples

input

5
4 5 1 3 2

output

3

input

7
1 6 5 3 4 7 2

output

6

input

6
6 5 4 3 2 1

output

5

Note

In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.

题意：题面很简单，问交换一次两个数的位置使得最大值与最小值之间的距离最大

思路：对于最大值我们自然会有两种方式，放在最左边或者最右边，计算此时的距离就行。

#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,data;

    int ans = 0 ;

    cin>>n;

    for(int i = 1;i<=n;i++)
    {
        cin >>data;

        if(data == 1 || data == n)
        {
            ans = max(ans,max(i,n-i+1));
        }
    }

    cout<<ans-1<<endl;
    return 0;
}

B. Pyramid of Glasses

time limit per test:1 second	memory limit per test:256 megabytes

Mary has just graduated from one well-known University and is now attending celebration party. Students like to dream of a beautiful life, so they used champagne glasses to construct a small pyramid. The height of the pyramid is n. The top level consists of only 1 glass, that stands on 2 glasses on the second level (counting from the top), then 3 glasses on the third level and so on.The bottom level consists of n glasses.

Vlad has seen in the movies many times how the champagne beautifully flows from top levels to bottom ones, filling all the glasses simultaneously. So he took a bottle and started to pour it in the glass located at the top of the pyramid.

Each second, Vlad pours to the top glass the amount of champagne equal to the size of exactly one glass. If the glass is already full, but there is some champagne flowing in it, then it pours over the edge of the glass and is equally distributed over two glasses standing under. If the overflowed glass is at the bottom level, then the champagne pours on the table. For the purpose of this problem we consider that champagne is distributed among pyramid glasses immediately. Vlad is interested in the number of completely full glasses if he stops pouring champagne in t seconds.

Pictures below illustrate the pyramid consisting of three levels.

Input

The only line of the input contains two integers n and t (1 ≤ n ≤ 10, 0 ≤ t ≤ 10 000) — the height of the pyramid and the number of seconds Vlad will be pouring champagne from the bottle.

Output

Print the single integer — the number of completely full glasses after t seconds.

Examples

input

3 5

output

4

input

4 8

output

6

Note

In the first sample, the glasses full after 5 seconds are: the top glass, both glasses on the second level and the middle glass at the bottom level. Left and right glasses of the bottom level will be half-empty.

题意：用酒杯组成一个金字塔，从最上面的杯子倒香槟，问n层的酒杯塔，t秒后有多少酒杯是满的。（每秒倒一个酒杯容量的香槟）。

思路：开始的时候，想要计算某个杯子灌满的时间，后来发现状态太复杂，其实最简单的方法是先将t容量的酒倒出，然后在向两边分，最后判断杯子的容量是否大于等译即可。

#include <bits/stdc++.h>

using namespace std;

double  Dp[11][11];

int main()
{
    int n,t;

    cin>>n>>t;

    memset(Dp,0,sizeof(Dp));

    Dp[1][1] = t;

    for(int i = 1;i<n;i++)
    {
        for(int j = 1;j<=i;j++)
        {
            if(Dp[i][j]<1) continue;

            Dp[i+1][j] += (Dp[i][j]-1)/2;

            Dp[i+1][j+1] += (Dp[i][j]-1)/2;
        }
    }

    int ans = 0;
    for(int i = 1;i<=n;i++)
        for(int j = 1;j<=i;j++)
            if(Dp[i][j] >= 1) ans++;
    cout<<ans<<endl;
    return 0;
}

C. Vasya and String

time limit per test:1 second	memory limit per test:256 megabytes

High school student Vasya got a string of length n as a birthday present. This string consists of letters ‘a’ and ‘b’ only. Vasya denotes beauty of the string as the maximum length of a substring (consecutive subsequence) consisting of equal letters.

Vasya can change no more than k characters of the original string. What is the maximum beauty of the string he can achieve?

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 100 000, 0 ≤ k ≤ n) — the length of the string and the maximum number of characters to change.

The second line contains the string, consisting of letters ‘a’ and ‘b’ only.

Output

Print the only integer — the maximum beauty of the string Vasya can achieve by changing no more than k characters.

Examples

input

4 2
abba

output

4

input

8 1
aabaabaa
output
5

Note

In the first sample, Vasya can obtain both strings “aaaa” and “bbbb”.
In the second sample, the optimal answer is obtained with the string “aaaaabaa” or with the string “aabaaaaa”.

题意：给你一个仅含有a，b的字符串，你有k次机会修该某一个字符。问你最长的相同字符的字符串的长度。

思路：比较裸的取尺法。由于只有两种字符，枚举相同的字符，用取尺法求出k次机会下的最长的序列长度。

#include <bits/stdc++.h>

using namespace std;

char str[100100];

int main()
{
    int n, k, len;

    scanf("%d %d",&n,&k);

    scanf("%s",str);

    len = strlen(str);

    int  l = 0 ,num = 0,ans = 0;

    for(int i = 0;i<len;i++)
    {
        if(str[i] == 'a')
        {
            num++;
        }

        while(l<=i&&num>k)
        {
            if(str[l] == 'a')
            {
                num --;
            }

            l++;
        }

        ans = max(ans,i-l+1);
    }


    l = 0,  num = 0;

    for(int i = 0;i<len;i++)
    {
        if(str[i] == 'b')
        {
            num++;
        }

        while(l<=i&&num>k)
        {
            if(str[l] == 'b')
            {
                num --;
            }

            l++;
        }

        ans = max(ans,i-l+1);
    }

    printf("%d\n",ans);

    return 0;
}

D. Theseus and labyrinth

|time limit per test:3 seconds|memory limit per test:256 megabytes|

Theseus has just arrived to Crete to fight Minotaur. He found a labyrinth that has a form of a rectangular field of size n × m and consists of blocks of size 1 × 1.

Each block of the labyrinth has a button that rotates all blocks 90 degrees clockwise. Each block rotates around its center and doesn’t change its position in the labyrinth. Also, each block has some number of doors (possibly none). In one minute, Theseus can either push the button in order to rotate all the blocks 90 degrees clockwise or pass to the neighbouring block. Theseus can go from block A to some neighbouring block B only if block A has a door that leads to block B and block B has a door that leads to block A.

Theseus found an entrance to labyrinth and is now located in block (xT, yT) — the block in the row xT and column yT. Theseus know that the Minotaur is hiding in block (xM, yM) and wants to know the minimum number of minutes required to get there.

Theseus is a hero, not a programmer, so he asks you to help him.

Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in labyrinth, respectively.

Each of the following n lines contains m characters, describing the blocks of the labyrinth. The possible characters are:

«+» means this block has 4 doors (one door to each neighbouring block);
«-» means this block has 2 doors — to the left and to the right neighbours;
«|» means this block has 2 doors — to the top and to the bottom neighbours;
«^» means this block has 1 door — to the top neighbour;
«>» means this block has 1 door — to the right neighbour;
«<» means this block has 1 door — to the left neighbour;
«v» means this block has 1 door — to the bottom neighbour;
«L» means this block has 3 doors — to all neighbours except left one;
«R» means this block has 3 doors — to all neighbours except right one;
«U» means this block has 3 doors — to all neighbours except top one;
«D» means this block has 3 doors — to all neighbours except bottom one;
«*» means this block is a wall and has no doors.

Left, right, top and bottom are defined from representing labyrinth as a table, where rows are numbered from 1 to n from top to bottom and columns are numbered from 1 to m from left to right.

Next line contains two integers — coordinates of the block (xT, yT) (1 ≤ xT ≤ n, 1 ≤ yT ≤ m), where Theseus is initially located.

Last line contains two integers — coordinates of the block (xM, yM) (1 ≤ xM ≤ n, 1 ≤ yM ≤ m), where Minotaur hides.

It’s guaranteed that both the block where Theseus starts and the block where Minotaur is hiding have at least one door. Theseus and Minotaur may be initially located at the same block.

Output

If Theseus is not able to get to Minotaur, then print -1 in the only line of the output. Otherwise, print the minimum number of minutes required to get to the block where Minotaur is hiding.

Examples

input

2 2
+*
*U
1 1
2 2

output

-1

input

2 3
<><
><>
1 1
2 1

output

4

Note

Assume that Theseus starts at the block (xT, yT) at the moment 0.

题意：给你一个n×m的矩阵，每一个格子中都有一个字符，有不同的含义。给你起点和终点，问你最少多少不到达终点。在每一个格子除了对应的方向可以走外，还可以停在原处，将每个格子的字符顺时针旋转 90∘ 。在本题中的想通是指相互可达。

思路：BFS的模拟，由于旋转只会出现4种情况，所以可以提前处理出来。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <queue>
#include <algorithm>

using namespace std;

typedef struct node
{
    int z,x,y,num;

    node(){}

    node(int _z,int _x,int _y,int _num):z(_z),x(_x),y(_y),num(_num){}
}op;

char mp[5][1100][1100];

char Ch[200];

int sx,sy,tx,ty;

int n,m;

bool vis[5][1100][1100];

int Dir[][2] = {{-1,0},{1,0},{0,-1},{0,1}};

bool Dir_U(char c )
{
    if(c == '+' || c == '|' || c == '^' || c == 'L' || c== 'R' || c == 'D') return true;

    return false;
}

bool Dir_D(char c)
{
    if(c == '+' || c == '|' || c == 'v' || c == 'L' || c== 'R' || c == 'U') return true;

    return false;
}

bool Dir_L(char c)
{
    if(c == '+' || c == '-' || c == '<' || c == 'D' || c== 'R' || c == 'U') return true;

    return false;
}

bool Dir_R(char c)
{
    if(c == '+' || c == '-' || c == '>' || c == 'L' || c== 'D' || c == 'U') return true;

    return false;
}

bool Judge(int z,int x,int y)
{
    if((z>=0&&z<4) && (x >= 0 && x < n) && (y >= 0 && y < m) && !vis[z][x][y] && mp[z][x][y] != '*') return true;

    return false;
}

int BFS()
{
    memset(vis,false,sizeof(vis));

    queue<op>Q;

    Q.push(op(0,sx,sy,0));

    vis[0][sx][sy] = true;

    while(!Q.empty())
    {
        op u = Q.front(); Q.pop();

        op v;

        if(u.x == tx && u.y == ty)
        {
            return u.num;
        }

        for(int i = 0;i <=4;i++)
        {
            if(i<4)
            {
                v.z = u.z;

                v.x = u.x+Dir[i][0]; 

                v.y = u.y+Dir[i][1];

                v.num = u.num+1;
            }
            else 
            {
                v = u;

                v.z=(v.z+1)%4;

                v.num++;
            }

            if(i == 0 && Judge(v.z,v.x,v.y) && Dir_U(mp[u.z][u.x][u.y]) && Dir_D(mp[v.z][v.x][v.y]))
            {
                Q.push(v);

                vis[v.z][v.x][v.y] = true;
            }
            else if(i == 1 && Judge(v.z,v.x,v.y) && Dir_D(mp[u.z][u.x][u.y]) && Dir_U(mp[v.z][v.x][v.y]))
            {
                Q.push(v);

                vis[v.z][v.x][v.y] = true;
            }
            else if(i == 2 && Judge(v.z,v.x,v.y) && Dir_L(mp[u.z][u.x][u.y]) && Dir_R(mp[v.z][v.x][v.y]))
            {
                Q.push(v);

                vis[v.z][v.x][v.y] = true;
            }
            else if(i == 3 && Judge(v.z,v.x,v.y) && Dir_R(mp[u.z][u.x][u.y]) && Dir_L(mp[v.z][v.x][v.y]))
            {
                Q.push(v);

                vis[v.z][v.x][v.y] = true;
            }
            else if(i == 4 && Judge(v.z,v.x,v.y))
            {
                Q.push(v);

                vis[v.z][v.x][v.y] = true;
            }
        }
    }

    return -1;

}

int main()
{
    Ch['+'] = '+';

    Ch['-'] = '|';

    Ch['|'] = '-';

    Ch['>'] = 'v';

    Ch['^'] = '>';

    Ch['<'] = '^';

    Ch['v'] = '<';

    Ch['L'] = 'U';

    Ch['R'] = 'D';

    Ch['U'] = 'R';

    Ch['D'] = 'L';

    Ch['*'] = '*';

    scanf("%d %d",&n,&m);

    for(int i = 0;i<n;i++)
        scanf("%s",mp[0][i]);

    for(int k = 1; k < 4;k++)
    {
        for(int i = 0;i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                mp[k][i][j] = Ch[mp[k-1][i][j]];
            }
        }
    }

    scanf("%d %d %d %d",&sx,&sy,&tx,&ty);

    sx--, sy--,tx--, ty-- ;

    if(sx == tx && sy == ty)
    {
        printf("0\n");
    }
    else 
    {
        printf("%d\n",BFS());
    }

    return 0;
}