CF550 DIV3

zoukankan html css js c++ java

CF550 DIV3
A - Diverse Strings CodeForces - 1144A

A string is called diverse if it contains consecutive (adjacent) letters of the Latin alphabet and each letter occurs exactly once. For example, the following strings are diverse: "fced", "xyz", "r" and "dabcef". The following string are notdiverse: "az", "aa", "bad" and "babc". Note that the letters 'a' and 'z' are not adjacent.

Formally, consider positions of all letters in the string in the alphabet. These positions should form contiguous segment, i.e. they should come one by one without any gaps. And all letters in the string should be distinct (duplicates are not allowed).

You are given a sequence of strings. For each string, if it is diverse, print "Yes". Otherwise, print "No".

Input

The first line contains integer $n$

Output

Print $n$

Example
Input

8 fced xyz r dabcef az aa bad babc

Output

Yes Yes Yes Yes No No No No
题意：给你一个字符串，看这个字符串的字符排完序是否是连续的。
解法就题意我把这个字符串排个序，然后遍历看是否连续，是连续输出 YES 否则输出 NO。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> using namespace std; typedef long long LL; const int maxn=100005; int n; char s[maxn]; int a[maxn]; int main() { scanf("%d",&n); while(n--) { scanf("%s",s); int len=strlen(s); for(int i=0;i<len;i++) { a[i]=s[i]-'a'; } sort(a,a+len); bool flag=false; // for(int i=0;i<len;i++) // cout<<a[i]<<" "; // cout<<endl; for(int i=0;i<len-1;i++) { if(a[i]==a[i+1]-1) continue; else { flag=true; break; } } if(flag) printf("No "); else printf("Yes "); } return 0; }

B - Parity Alternated Deletions CodeForces - 1144B

Polycarp has an array $a$

He wants to play a game with this array. The game consists of several moves. On the first move he chooses any element and deletes it (after the first move the array contains $n - 1$

Formally:

If it is the first move, he chooses any element and deletes it;

If it is the second or any next move:If after some move Polycarp cannot make a move, the game ends.

if the last deleted element was odd, Polycarp chooses any even element and deletes it;

if the last deleted element was even, Polycarp chooses any odd element and deletes it.

Polycarp's goal is to minimize the sum of non-deleted elements of the array after end of the game. If Polycarp can delete the whole array, then the sum of non-deletedelements is zero.

Help Polycarp find this value.

Input

The first line of the input contains one integer $n$

The second line of the input contains $n$

Output

Print one integer — the minimum possible sum of non-deleted elements of the array after end of the game.

Examples

Input

5 1 5 7 8 2

Output

0

Input

6 5 1 2 4 6 3

Output

0

Input

2 1000000 1000000

Output

1000000
题意：给你一组数，按奇数偶数交错拿，直接最后不能拿了，要保证剩下的数值和最小。
思路：开两个优先队列，记录奇数和偶数的数量，因为是交错的拿，所以pop 奇数偶数两者最小值次，那么剩下的就是不能拿的了。
注意为什么要加一个

if(!q1.empty()) q1.pop(); if(!q0.empty()) q0.pop()；
因为按着交错的拿的话，肯定有一个会被拿空，但是是交错的拿的话我可以选择先拿那个多的，比方说我有三个奇数，两个偶数，我按数量最少的偶数个数2 pop，但是注意我可以先拿奇数的，最后就可以多拿一个奇数所以要多一个奇数。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <queue> using namespace std; typedef long long LL; const int maxn=100005; int n; int cnt1,cnt0; int a[maxn]; int main() { scanf("%d",&n); cnt0=cnt1=0; priority_queue<int>q1,q0; for(int i=1;i<=n;i++) { scanf("%d",&a[i]); if(a[i]%2) { cnt1++; q1.push(a[i]); } else { cnt0++; q0.push(a[i]); } } int cnt=min(cnt1,cnt0); while(cnt--) { if(!q1.empty()) q1.pop(); if(!q0.empty()) q0.pop(); } if(!q1.empty()) q1.pop(); if(!q0.empty()) q0.pop(); int ans=0; while(!q1.empty()) { ans+=q1.top(); q1.pop(); } while(!q0.empty()) { ans+=q0.top(); q0.pop(); } printf("%d ",ans); return 0; }

C - Two Shuffled Sequences CodeForces - 1144C

Two integer sequences existed initially — one of them was strictly increasing, and the other one — strictly decreasing.

Strictly increasing sequence is a sequence of integers $[x_{1} < x_{2} < \dots < x_{k}]$

They were merged into one sequence $a$

This shuffled sequence $a$

Your task is to find any two suitable initial sequences. One of them should be strictly increasing and the other one — strictly decreasing. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.

If there is a contradiction in the input and it is impossible to split the given sequence $a$

Input

The first line of the input contains one integer $n$

The second line of the input contains $n$

Output

If there is a contradiction in the input and it is impossible to split the given sequence $a$

Otherwise print "YES" in the first line and any two suitable sequences. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.

In the second line print $n_{i}$

In the third line print $n_{i}$

In the fourth line print $n_{d}$

In the fifth line print $n_{d}$

$n_{i} + n_{d}$

Examples

Input

7 7 2 7 3 3 1 4

Output

YES 2 3 7 5 7 4 3 2 1

Input

5 4 3 1 5 3

Output

YES 1 3 4 5 4 3 1

Input

5 1 1 2 1 2

Output

NO

Input

5 0 1 2 3 4

Output

YES 0 5 4 3 2 1 0
题意：给你一个数组，看能不能分为两个数组，一个递增，一个递减，位置可以变换。
解法：开两个vector 存数，然后拍个序即可，唯一不合条件的就是某个数出现了多余两次。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <queue> #include <vector> using namespace std; typedef long long LL; const int maxn=200005; int n; vector<int>v1,v2; int a[maxn],cnt[maxn]; bool flag=false; bool cmp(int x,int y) { return x>y; } int main() { scanf("%d",&n); for(int i=1;i<=n;i++) { scanf("%d",&a[i]); cnt[a[i]]++; if(cnt[a[i]]==1) v1.push_back(a[i]); else if(cnt[a[i]]==2) v2.push_back(a[i]); else flag=true; } if(flag) printf("NO "); else { printf("YES "); sort(v1.begin(),v1.end()); sort(v2.begin(),v2.end(),cmp); printf("%d ",v1.size()); for(vector<int>::iterator it=v1.begin();it!=v1.end();it++) printf("%d ",*it); printf(" "); printf("%d ",v2.size()); for(vector<int>::iterator it=v2.begin();it!=v2.end();it++) printf("%d ",*it); printf(" "); } return 0; }

D - Equalize Them All CodeForces - 1144D

You are given an array $a$

Choose a pair of indices $(i, j)$

Choose a pair of indices $(i, j)$

The value $| x |$

Your task is to find the minimum number of operations required to obtain the array of equal elements and print the order of operations to do it.

It is guaranteed that you always can obtain the array of equal elements using such operations.

Note that after each operation each element of the current array should not exceed $10^{18}$

Input

The first line of the input contains one integer $n$

The second line of the input contains $n$

Output

In the first line print one integer $k$

In the next $k$

Note that after each operation each element of the current array should not exceed $10^{18}$

If there are many possible answers, you can print any.

Examples

Input

5 2 4 6 6 6

Output

2 1 2 3 1 1 2

Input

3 2 8 10

Output

2 2 2 1 2 3 2

Input

4 1 1 1 1

Output

0
题意：

给出N个数, 对任意相邻的两个数ai, aj有两种操作：set ai:=ai+|ai−aj|; set ai:=ai−|ai−aj|.

求最少进行多少次操作, 可以使得所有数全部相等。发现对于任意的两个数进行一次操作均可使其相等, 同时可以向左/向右传递.
这样一来使得所有数均为出现次数最多的数毫无疑问就是最优策略了。所以就是找众数，找到之后把其他的往这边转换。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <queue> #include <vector> using namespace std; typedef long long LL; const int maxn=200005; int n; vector<int>v1,v2; int a[maxn],vis[maxn]; int id,maxx; int main() { scanf("%d",&n); for(int i=1;i<=n;i++) { scanf("%d",&a[i]); vis[a[i]]++; if(vis[a[i]]>maxx) { maxx=vis[a[i]]; id=i; } } printf("%d ",n-maxx); for(int i=id-1;i>=1;i--) { if(a[i]>a[i+1]) printf("2 %d %d ",i,i+1); else if(a[i]<a[i+1]) printf("1 %d %d ",i,i+1); a[i]=a[i+1]; } for(int i=id+1;i<=n;i++) { if(a[i]>a[i-1]) printf("2 %d %d ",i,i-1); else if(a[i]<a[i-1]) printf("1 %d %d ",i,i-1); a[i]=a[i-1]; } return 0; }

E - Median String CodeForces - 1144E

You are given two strings $s$

Let's consider list of all strings consisting of exactly $k$

Your task is to print the median (the middle element) of this list. For the example above this will be "bc".

It is guaranteed that there is an odd number of strings lexicographically not less than $s$

Input

The first line of the input contains one integer $k$

The second line of the input contains one string $s$

The third line of the input contains one string $t$

It is guaranteed that $s$

It is guaranteed that there is an odd number of strings lexicographically not less than $s$

Output

Print one string consisting exactly of $k$

Examples

Input

2 az bf

Output

bc

Input

5 afogk asdji

Output

alvuw

Input

6 nijfvj tvqhwp

Output

qoztvz
题意：给你两个只含有小写字母的字符串， s和t，保证s的字典序比t小。把s和t看成一个26进制的数，让你输出这两个数的中位数
解法：转换为十进制去做，首先把两个字符串的每一个位上的数值加起来，然后向前进位。然后从头开始遍历加起来的那个数值，如果数值为偶数，那么中位数的这一位就是数值/2，如果是奇数，那么中位数的这一位是/2且向下取整。
并把那个多余的一加到下一位中，（注意上一位的1到下一位是26），最后输出答案即可。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <queue> #include <vector> using namespace std; typedef long long LL; const int maxn=200005; int n; char s1[maxn],s2[maxn]; int a[maxn],b[maxn]; int ans[maxn]; int id,maxx; int main() { scanf("%d",&n); scanf("%s",s1); scanf("%s",s2); for(int i=0;i<n;i++) { a[i]=s1[i]-'a'+1; b[i]=s2[i]-'a'+1; } for(int i=0;i<n;i++) ans[i]=a[i]+b[i]; for(int i=0;i<n;i++) { if(ans[i]%2!=0) ans[i+1]+=26; ans[i]=ans[i]/2; } for(int i=n-1;i>=0;i--) { if(ans[i]>26) { ans[i]-=26; ans[i-1]++; } } for(int i=0;i<n;i++) printf("%c",ans[i]+'a'-1); return 0; }

F - Graph Without Long Directed Paths CodeForces - 1144F

You are given a connected undirected graph consisting of $n$

You have to direct its edges in such a way that the obtained directed graph does not contain any paths of length two or greater (where the length of path is denoted as the number of traversed edges).

Input

The first line contains two integer numbers $n$

The following $m$

Output

If it is impossible to direct edges of the given graph in such a way that the obtained directed graph does not contain paths of length at least two, print "NO" in the first line.

Otherwise print "YES" in the first line, and then print any suitable orientation of edges: a binary string (the string consisting only of '0' and '1') of length $m$

Example

Input

6 5 1 5 2 1 1 4 3 1 6 1

Output

YES 10100
题意：给定一个无向图，让其把边变成一个有向边，边的方向可以你自己定，but要求最后的图中任何一个路径的长度不能大于等于2。

解法：通过分析我们可以发现，要满足图中的任意一个路径的长度不大于等于2的话，那么对于任意一个节点i，如果它在一个边中做起点，那么就不能在另一个边中做终点。显然一个节点在它连接的所有的边中，只能做起点或者终点。直接dfs 跑染色。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <queue> #include <vector> using namespace std; typedef long long LL; const int maxn=200005; int n,m; vector<int>G[maxn]; int u[maxn],v[maxn]; int vis[maxn]; bool flag=false; void dfs(int x,int pre) { vis[x]=pre; int si=G[x].size(); for(int i=0;i<si;i++) { int to=G[x][i]; if(vis[to]) { if(pre==vis[to]) { flag=1; return ; } continue; } dfs(to,3-pre); } return ; } int main() { scanf("%d %d",&n,&m); for(int i=0;i<m;i++) { scanf("%d %d",&u[i],&v[i]); G[u[i]].push_back(v[i]); G[v[i]].push_back(u[i]); } dfs(1,1); if(flag) printf("NO "); else { printf("YES "); for(int i=0;i<m;i++) printf("%d",2-vis[u[i]]); printf(" "); } return 0; }

G - Two Merged Sequences CodeForces - 1144G

Two integer sequences existed initially, one of them was strictly increasing, and another one — strictly decreasing.

Strictly increasing sequence is a sequence of integers $[x_{1} < x_{2} < \dots < x_{k}]$

Elements of increasing sequence were inserted between elements of the decreasing one (and, possibly, before its first element and after its last element) without changing the order. For example, sequences $[1, 3, 4]$

Let the obtained sequence be $a$

If there is a contradiction in the input and it is impossible to split the given sequence $a$

Input

The first line of the input contains one integer $n$

The second line of the input contains $n$

Output

If there is a contradiction in the input and it is impossible to split the given sequence $a$

Otherwise print "YES" in the first line. In the second line, print a sequence of $n$

Examples

Input

9 5 1 3 6 8 2 9 0 10

Output

YES 1 0 0 0 0 1 0 1 0

Input

5 1 2 4 0 2

Output

NO
题意：将一个序列分成两个序列，两个序列中元素的相对顺序保持和原序列不变，使得分出的两个序列一个严格上升，一个严格下降。
解法：对于第 i 个数，我们应该分析什么情况可以放入升序什么情况放入降序；最容易的情况就是第 i 个数只能放在特定的一个序列中，与都不能放在序列中也就是 NO 的情况；
递增序列肯定希望最后一个数最小，递减序列肯定希望最后一个数最大，然而对于ai要么属于递增序列，要么属于递减序列。
因此比较ai和a(i+1)的大小，若ai>a(i+1)，则把ai放到递减序列尾部，否则放到递增序列尾部。注意一下不符合题意的判定以及相等元素的判定就好了。

#include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> #include <queue> #include <vector> using namespace std; typedef long long LL; const int INF=0x3f3f3f3f; const int maxn=200005; int n,m; int a[maxn],ans[maxn]; int maxx,minn; int main() { scanf("%d",&n); for(int i=1;i<=n;i++) scanf("%d",&a[i]); maxx=-INF,minn=INF; for(int i=1;i<=n;i++) { if(a[i]<=maxx && a[i]>=minn) { printf("NO "); return 0; } else if(a[i]>maxx && a[i]<minn) { if(a[i]>=a[i+1]) { minn=a[i]; ans[i]=1; } else maxx=a[i]; } else if(a[i]>maxx) maxx=a[i]; else { minn=a[i]; ans[i]=1; } } printf("YES "); for(int i=1;i<=n;i++) printf("%d ",ans[i]); printf(" "); return 0; }
查看全文

相关阅读:
Anders Hejlsberg 和 Erich Gamma
node-webkit
用户密码加密存储十问十答，一文说透密码安全存储
 Spring Security-- 验证码功能的实现
 BigDecimal 专题
 基于微信开发专题
 unwrapThrowable
Android PullToRefreshExpandableListView的点击事件
 Android The content of the adapter has changed but ListView did not receive a notification
Android入门：广播发送者与广播接收者

原文地址：https://www.cnblogs.com/jkzr/p/10675574.html

A - Diverse Strings CodeForces - 1144A

B - Parity Alternated Deletions CodeForces - 1144B

C - Two Shuffled Sequences CodeForces - 1144C

D - Equalize Them All CodeForces - 1144D

E - Median String CodeForces - 1144E

F - Graph Without Long Directed Paths CodeForces - 1144F

G - Two Merged Sequences CodeForces - 1144G