Educational Codeforces Round 35 (Rated for Div. 2) - （A，B，C，D）

A. Nearest Minimums

time limit per test
2 seconds

memory limit per test
256 megabytes

input
standard input

output
standard output

You are given an array of n integer numbers a0, a1, ..., an - 1.
Find the distance between two closest (nearest) minimums in it. It is guaranteed that in the array a minimum occurs at least two times.

Input

The first line contains positive integer n (2 ≤ n ≤ 105)
— size of the given array. The second line contains n integers a0, a1, ..., an - 1(1 ≤ ai ≤ 109)
— elements of the array. It is guaranteed that in the array a minimum occurs at least two times.

Output

Print the only number — distance between two nearest minimums in the array.

Examples

input

2
3 3

output

1

input

3
5 6 5

output

2

input

9
2 1 3 5 4 1 2 3 1

output

3

题意：给出长度为n的数组（一个数课出现多次），求其中最小的数在数组中的最小距离（保证最小的数出现多于2次）
代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define M 100005

int n;
int a[M];

int main()
{
int i;
scanf("%d",&n);
int minv=0x7fffffff;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
minv=min(a[i],minv);
}
int ans=0x7fffffff;
int it=-1;
for(i=1;i<=n;i++)
{
if(a[i]==minv)
{
it=i;
break;
}
}
for(i=it+1;i<=n;i++)
{
if(a[i]==minv)
{
ans=min(i-it,ans);
it=i;
}
}
printf("%d\n",ans);
return 0;
}

B. Two Cakes

time limit per test
1 second

memory limit per test
256 megabytes

input
standard input

output
standard output

It's New Year's Eve soon, so Ivan decided it's high time he started setting the table. Ivan has bought two cakes and cut them into pieces: the first cake has been cut into a pieces,
and the second one — into b pieces.

Ivan knows that there will be n people at the celebration (including himself), so Ivan has set n plates
for the cakes. Now he is thinking about how to distribute the cakes between the plates. Ivan wants to do it in such a way that all following conditions are met:

Each piece of each cake is put on some plate;

Each plate contains at least one piece of cake;

No plate contains pieces of both cakes.

To make his guests happy, Ivan wants to distribute the cakes in such a way that the minimum number of pieces on the plate is maximized. Formally, Ivan wants to know the maximum possible number x such
that he can distribute the cakes according to the aforementioned conditions, and each plate will contain at least x pieces of cake.

Help Ivan to calculate this number x!

Input

The first line contains three integers n, a and b (1 ≤ a, b ≤ 100, 2 ≤ n ≤ a + b)
— the number of plates, the number of pieces of the first cake, and the number of pieces of the second cake, respectively.

Output

Print the maximum possible number x such that Ivan can distribute the cake in such a way that each plate will contain at least x pieces
of cake.

Examples

input

5 2 3

output

1

input

4 7 10

output

3

Note

In the first example there is only one way to distribute cakes to plates, all of them will have 1 cake on it.

In the second example you can have two plates with 3 and 4 pieces
of the first cake and two plates both with 5 pieces of the second cake. Minimal number of pieces is 3.

题意：有n个盘子，2个蛋糕，第一个蛋糕可以分为a块，第二个蛋糕可以分为b块，按以下要求将蛋糕放入盘子中：

1.a+b块蛋糕，每块都放入某个盘子中
2.n个盘子，每个盘子都至少有一块蛋糕
3.一个盘子中不能有两个类型的蛋糕
问怎么摆放蛋糕能使得盘子中蛋糕块数最少的那个盘子的蛋糕块数最多。
代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define M 100005

int n,a,b;

int main()
{
scanf("%d%d%d",&n,&a,&b);

if(n==a+b)
{
printf("1\n");
}else{

int t1,t2;
int ans=-1;
int temp;
for(t1=1;t1<n;t1++)
{
t2=n-t1;
temp=666666;
temp=min(a/t1,temp);
temp=min(b/t2,temp);
ans=max(ans,temp);
}

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

return 0;
}

C. Three Garlands

time limit per test
2 seconds

memory limit per test
256 megabytes

input
standard input

output
standard output

Mishka is decorating the Christmas tree. He has got three garlands, and all of them will be put on the tree. After that Mishka will switch these garlands on.

When a garland is switched on, it periodically changes its state — sometimes it is lit, sometimes not. Formally, if i-th garland is
switched on during x-th second, then it is lit only during seconds x, x + ki, x + 2ki, x + 3ki and
so on.

Mishka wants to switch on the garlands in such a way that during each second after switching the garlands on there would be at least one lit garland. Formally, Mishka wants to choose three integers x1, x2 and x3 (not
necessarily distinct) so that he will switch on the first garland during x1-th
second, the second one — during x2-th
second, and the third one — during x3-th
second, respectively, and during each second starting from max(x1, x2, x3) at
least one garland will be lit.

Help Mishka by telling him if it is possible to do this!

Input

The first line contains three integers k1, k2 and k3 (1 ≤ ki ≤ 1500)
— time intervals of the garlands.

Output

If Mishka can choose moments of time to switch on the garlands in such a way that each second after switching the garlands on at least one garland will be lit, print YES.

Otherwise, print NO.

Examples

input

2 2 3

output

YES

input

4 2 3

output

NO

Note

In the first example Mishka can choose x1 = 1, x2 = 2, x3 = 1.
The first garland will be lit during seconds 1, 3, 5, 7, ..., the second — 2, 4, 6, 8, ...,
which already cover all the seconds after the 2-nd one. It doesn't even matter what x3 is
chosen. Our choice will lead third to be lit during seconds 1, 4, 7, 10, ..., though.

In the second example there is no way to choose such moments of time, there always be some seconds when no garland is lit.

题意：有3个灯，打开电源后三个灯分别每过k1,k2,k3秒亮一次，让任选打开三个灯的时间，看能否使得每秒都有灯是亮的
输入k1,k2,k3后升序排序，如果间隔最小的k1>3那么不可能做到使每秒都有灯亮，其余情况可在纸上画一画
代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define M 100005

int a[3];

int main()
{
scanf("%d%d%d",&a[0],&a[1],&a[2]);
sort(a,a+3);

bool flag=false;
if(a[0]==1)
{
flag=true;
}else if(a[0]==2)
{
if(a[1]==2)
flag=true;
else if(a[1]==4&&a[2]==4)
flag=true;
}else if(a[0]==3)
{
if(a[2]==3)
flag=true;
}else if(a[0]>3){
flag=false;
}

if(flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}

D. Inversion Counting

time limit per test
2 seconds

memory limit per test
256 megabytes

input
standard input

output
standard output

A permutation of size n is an array of size n such
that each integer from 1 to n occurs
exactly once in this array. An inversion in a permutation p is a pair of indices (i, j) such
that i > j and ai < aj.
For example, a permutation [4, 1, 3, 2] contains 4 inversions: (2, 1), (3, 1), (4, 1), (4, 3).

You are given a permutation a of size n and m queries
to it. Each query is represented by two indices l and r denoting
that you have to reverse the segment [l, r] of the permutation. For example, if a = [1, 2, 3, 4] and
a query l = 2, r = 4 is
applied, then the resulting permutation is [1, 4, 3, 2].

After each query you have to determine whether the number of inversions is odd or even.

Input

The first line contains one integer n (1 ≤ n ≤ 1500)
— the size of the permutation.

The second line contains n integers a1, a2,
..., an (1 ≤ ai ≤ n)
— the elements of the permutation. These integers are pairwise distinct.

The third line contains one integer m (1 ≤ m ≤ 2·105)
— the number of queries to process.

Then m lines follow, i-th
line containing two integers li, ri (1 ≤ li ≤ ri ≤ n)
denoting that i-th query is to reverse a segment [li, ri] of
the permutation. All queries are performed one after another.

Output

Print m lines. i-th
of them must be equal to odd if the number of inversions in the permutation after i-th
query is odd, and even otherwise.

Examples

input

31 2 321 22 3

output

odd
even

input

4
1 2 4 34
1 11 4
1 4
2 3

output

odd
odd
odd
even

Note

The first example:

after the first query a = [2, 1, 3], inversion: (2, 1);

after the second query a = [2, 3, 1], inversions: (3, 1), (3, 2).

The second example:

a = [1, 2, 4, 3], inversion: (4, 3);

a = [3, 4, 2, 1], inversions: (3, 1), (4, 1), (3, 2), (4, 2), (4, 3);

a = [1, 2, 4, 3], inversion: (4, 3);

a = [1, 4, 2, 3], inversions: (3, 2), (4, 2).

题意：给出一个长度为n的排列，m次操作，每次操作给出区间[l,r]意思是让使原排列中a[l]~a[r]的元素反转，让求每次操作反转之后新排列的逆序数

先求出所有的逆序数ans，对于一次操作[L,R]之间这t=（R-L+1）个数，在反转区间之后，任意两个数之间都相当于交换了位置，又因为任意两个数是不相等的，所以每有一次交换（共有组合数C(t,2)个交换），ans的奇偶改变一次，因为只要判断奇偶所以不用管数之间的大小

if(t&1)

代码：

//ori^=1 运算一次奇偶变一次
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<queue>
#include<cstring>
#include<map>
using namespace std;
typedef long long ll;
#define pi acos(-1.0)
#define inf 0x3f3f3f
#define M 1505

int n,m,ans;
int a[M];

int main()
{
int i,j,l,r;
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&a[i]);
ans=0;
for(i=1;i<=n;i++)  //先求出所有逆序数，并判断奇偶
for(j=i+1;j<=n;j++)
{
if(a[i]>a[j])
ans^=1;   //ans=1 -> odd, ans=0 -> even
}
scanf("%d",&m);
while(m--)
{
scanf("%d%d",&l,&r);
int t=r-l+1;
t=t*(t-1)/2; //[L,R]之间这t个数，在反转排列之后，任意两个数之间都相当于交换了位置，有因为任意两个数是不相等的，所以有一次交换ans的奇偶改变一次，又因为只要判断奇偶所以不用管数之间的大小
if(t&1)
ans^=1;

if(ans)
printf("odd\n");
else
printf("even\n");
}
return 0;
}