Codeforces Round #410 (Div. 2)A B C D 暴力 暴力 思路 姿势/随机

A. Mike and palindrome

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Mike has a string s consisting of only lowercase English letters. He wants to change exactly one character from the string so that the resulting one is a palindrome.

A palindrome is a string that reads the same backward as forward, for example strings "z", "aaa", "aba", "abccba" are palindromes, but strings "codeforces", "reality", "ab" are not.

Input

The first and single line contains string s (1 ≤ |s| ≤ 15).

Output

Print "YES" (without quotes) if Mike can change exactly one character so that the resulting string is palindrome or "NO" (without quotes) otherwise.

Examples

Input

abccaa

Output

YES

Input

abbcca

Output

NO

Input

abcda

Output

YES

题意：必须且只更改一个字符 能否使得字符串回文 是则输出“YES”否则输出"NO"
题解：暴力每个字符的更改，并check是否回文

#include<bits/stdc++.h>
using namespace std;
#define ll __int64
const int N=1e5+10;
char a[105];
int  main()
{
    scanf("%s",a);
    int len=strlen(a);
    for(int i=0;i<len;i++)
    {
        for(int j='a';j<='z';j++)
        {
            if(a[i]==j)
                continue;
            char exm=a[i];
            a[i]=j;
            int jishu=0;
            for(int k=0;k<len/2;k++)
            {
                if(a[k]==a[len-k-1])
                    jishu++;
            }
            if(jishu==(len/2))
            {
                printf("YES
");
                return 0;
            }
            a[i]=exm;
        }
    }
    printf("NO
");
    return 0;
}

B. Mike and strings

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Mike has n strings s₁, s₂, ..., s_n each consisting of lowercase English letters. In one move he can choose a string s_i, erase the first character and append it to the end of the string. For example, if he has the string "coolmike", in one move he can transform it into the string "oolmikec".

Now Mike asks himself: what is minimal number of moves that he needs to do in order to make all the strings equal?

Input

The first line contains integer n (1 ≤ n ≤ 50) — the number of strings.

This is followed by n lines which contain a string each. The i-th line corresponding to string s_i. Lengths of strings are equal. Lengths of each string is positive and don't exceed 50.

Output

Print the minimal number of moves Mike needs in order to make all the strings equal or print  - 1 if there is no solution.

Examples

Input

4
xzzwo
zwoxz
zzwox
xzzwo

Output

5

Input

2
molzv
lzvmo

Output

2

Input

3
kc
kc
kc

Output

0

Input

3
aa
aa
ab

Output

-1

Note

In the first sample testcase the optimal scenario is to perform operations in such a way as to transform all strings into "zwoxz".

题意：给你n个串 对字符串有一种操作（将当前的首个字符放到最后) 问对这n个字符串最少要执行多少次操作使得n个串相同 若无法达到则输出-1

题解：首先判断n个串是否能够达到相同状态，任意取一个串生成一个二倍串 判断其他串是否为这个二倍串的子串即可。若能够到达相同状态，则枚举每个二倍串的子串，统计操作次数，取最小值输出。

#include<bits/stdc++.h>
using namespace std;
#define ll __int64
const int N=1e5+10;
char a[100][100];
char b[100];
char c[100];
int n;
map<string,int>mp;
map<string,int>ji;
int main()
{
    string str,str1,str2;
    int ans=1000000000;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%s",a[i]);
        str.assign(a[i]);
        mp[a[i]]++;
        }
    int len=strlen(a[0]);
    for(int i=0;i<len;i++)
    {
        b[i]=a[0][i];
        b[i+len]=a[0][i];
    }
    int jishu=0;
    for(int i=0;i<n;i++)
    {
        if(strstr(b,a[i]))
            jishu++;
    }
    if(jishu!=n)
      printf("-1
");
    else
    {
        for(int i=0;i<len;i++)
        {
            ji.clear();
            int exm=i;
            int jishu=len;
            int w=0;
            while(jishu--)
            {
              c[w]=b[exm];
              c[w+len]=b[exm];
              w++;exm++;
            }
            int bu=0;
            int zong=0;
            for(int j=len;j>=0;j--)
            {
                str.assign(c,j,len);
                if(ji[str]==0)
                {
                  zong=zong+bu*mp[str];
                  bu++;
                  ji[str]=1;
                }
            }
            ans=min(ans,zong);
        }
        printf("%d
",ans);
    }
    return 0;
}

C. Mike and gcd problem

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Mike has a sequence A = [a₁, a₂, ..., a_n] of length n. He considers the sequence B = [b₁, b₂, ..., b_n] beautiful if the gcd of all its elements is bigger than 1, i.e. .

Mike wants to change his sequence in order to make it beautiful. In one move he can choose an index i (1 ≤ i < n), delete numbers a_i, a_i + 1 and put numbers a_i - a_i + 1, a_i + a_i + 1 in their place instead, in this order. He wants perform as few operations as possible. Find the minimal number of operations to make sequence A beautiful if it's possible, or tell him that it is impossible to do so.

is the biggest non-negative number d such that d divides b_i for every i (1 ≤ i ≤ n).

Input

The first line contains a single integer n (2 ≤ n ≤ 100 000) — length of sequence A.

The second line contains n space-separated integers a₁, a₂, ..., a_n (1 ≤ a_i ≤ 10⁹) — elements of sequence A.

Output

Output on the first line "YES" (without quotes) if it is possible to make sequence A beautiful by performing operations described above, and "NO" (without quotes) otherwise.

If the answer was "YES", output the minimal number of moves needed to make sequence A beautiful.

Examples

Input

2
1 1

Output

YES
1

Input

3
6 2 4

Output

YES
0

Input

2
1 3

Output

YES
1

Note

In the first example you can simply make one move to obtain sequence [0, 2] with .

In the second example the gcd of the sequence is already greater than 1.

题意：给你n个数  一种操作（更改a_i, a_{i + 1   -->} a_i - a_i + 1, a_i + a_i + 1 ）问你最少要执行多少次操作才能使得>1

题解：对 a b执行操作 (a,b)->(a-b,a+b)->(-2b,2a)->(-2b-2a,-2b+2a)->.... 对任意两个数执行最多两次操作即可都变为偶数；

为了满足>1 最小的gcd为2 并且所有偶数的的gcd为2 所以若初始的gcd就是大于1则不需要操作，否则遍历一遍n个数，执行最少的操作使得所有的数都为偶数，注意最后一个数。

#include<bits/stdc++.h>
using namespace std;
#define ll __int64
const int N=1e5+10;
int n;
ll a[N];
int main()
{
    scanf("%d",&n);
    scanf("%I64d",&a[1]);
    scanf("%I64d",&a[2]);
    ll zong=__gcd(a[1],a[2]);
    for(int i=3; i<=n; i++)
    {
        scanf("%I64d",&a[i]);
        zong=__gcd(zong,a[i]);
    }
    if(zong>1)
    {
        printf("YES
0
");
        return 0;
    }
    ll ans=0;
    ll aa,bb;
    ll aaa,bbb;
    for(int i=1; i<n; i++)
    {
        if(a[i]%2==0)
            continue;
        aa=a[i]-a[i+1];
        bb=a[i]+a[i+1];
        ans++;
        if(aa%2==0)
        {
            a[i+1]=bb;
            continue;
        }
        aaa=aa-bb;
        bbb=aa+bb;
        ans++;
        if(aaa%2==0)
        {
            a[i+1]=bbb;
            continue;
        }
    }
    int flag=0;
    if(a[n]%2==1)
    {
        aa=a[n-1]-a[n];
        bb=a[n-1]+a[n];
        ans++;
        if(aa%2==0&&bb%2==0)
        {
            flag=1;
        }
        if(flag==0)
        {
            ans++;
        }
    }
    printf("YES
");
    printf("%I64d
",ans);
    return 0;
}

D. Mike and distribution

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Mike has always been thinking about the harshness of social inequality. He's so obsessed with it that sometimes it even affects him while solving problems. At the moment, Mike has two sequences of positive integers A = [a₁, a₂, ..., a_n] and B = [b₁, b₂, ..., b_n] of length n each which he uses to ask people some quite peculiar questions.

To test you on how good are you at spotting inequality in life, he wants you to find an "unfair" subset of the original sequence. To be more precise, he wants you to select k numbers P = [p₁, p₂, ..., p_k] such that 1 ≤ p_i ≤ n for 1 ≤ i ≤ k and elements in P are distinct. Sequence P will represent indices of elements that you'll select from both sequences. He calls such a subset P "unfair" if and only if the following conditions are satisfied: 2·(a_p1 + ... + a_pk) is greater than the sum of all elements from sequence A, and 2·(b_p1 + ... + b_pk) is greater than the sum of all elements from the sequence B. Also, k should be smaller or equal to because it will be to easy to find sequence P if he allowed you to select too many elements!

Mike guarantees you that a solution will always exist given the conditions described above, so please help him satisfy his curiosity!

Input

The first line contains integer n (1 ≤ n ≤ 10⁵) — the number of elements in the sequences.

On the second line there are n space-separated integers a₁, ..., a_n (1 ≤ a_i ≤ 10⁹) — elements of sequence A.

On the third line there are also n space-separated integers b₁, ..., b_n (1 ≤ b_i ≤ 10⁹) — elements of sequence B.

Output

On the first line output an integer k which represents the size of the found subset. k should be less or equal to .

On the next line print k integers p₁, p₂, ..., p_k (1 ≤ p_i ≤ n) — the elements of sequence P. You can print the numbers in any order you want. Elements in sequence P should be distinct.

Example

Input

5
8 7 4 8 3
4 2 5 3 7

Output

3
1 4 5
题意：给你长度为n的a，b数组 在a，b数组的相同位置取出

个数 使得a数组中取出的数的和的2倍大于a数组的和 并且b数组中取出的数的和的2倍大于b数组的和
题解：排序姿势/随机姿势/orzzzz

#include<bits/stdc++.h>
using namespace std;
int n;
struct node
{
    int x;
    int y;
    int id;
}N[100005];
int check[100005];
bool  cmp( struct node aa,struct node bb)
{
    return aa.x>bb.x;
}
int main()
{
    scanf("%d",&n);
    memset(N,0,sizeof(N));
    memset(check,0,sizeof(check));
    for(int i=1;i<=n;i++)
        scanf("%d",&N[i].x);
    for(int i=1;i<=n;i++)
        scanf("%d",&N[i].y);
    for(int i=1;i<=n;i++)
        N[i].id=i;
    sort(N+1,N+1+n,cmp);
    int k;
    if(n%2==0)
        k=1;
    else{
        k=2;
        }
    for(;k<=n;k+=2)
    {
        if(N[k].y>N[k+1].y)
            check[N[k].id]=1;
        else
            check[N[k+1].id]=1;
    }
    for(int i=1;i<=n;i++)
    {
        if(check[N[i].id]==0)
        {
            check[N[i].id]=1;
            break;
        }
    }
    printf("%d
",n/2+1);
    for(int i=1;i<=n;i++)
    {
        if(check[N[i].id])
            printf("%d ",N[i].id);
    }
    printf("
");
    return 0;
}

 //随机写法

#include<bits/stdc++.h>
using namespace std;
long long a[100005],b[100005],c[100005];
int main ( ) {
    long long n,i,k,sa=0,sb=0;
    scanf("%I64d",&n);
    k=n/2+1;
    for (i=1;i<=n;i++) scanf("%I64d",&a[i]),c[i]=i,sa+=a[i];
    for (i=1;i<=n;i++) scanf("%I64d",&b[i]),sb+=b[i];
    while (true) {
        bool f=true;
        long long s1=0,s2=0;
        for (i=1;i<=k;i++) {
            s1+=a[c[i]];s2+=b[c[i]];
        }
        if (s1*2>sa && s2*2>sb) {
            printf("%d
",k);
            for (i=1;i<=k;i++) printf("%d ",c[i]);
            return 0;
        }
        random_shuffle(c+1,c+n+1);
    }
    return 0;
}

使得a数组中取出的数的和的2倍大于a数组的和