CodeForces Round #550 Div.3
http://codeforces.com/contest/1144
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 not diverse: "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".
The first line contains integer nn (1≤n≤1001≤n≤100), denoting the number of strings to process. The following nn lines contains strings, one string per line. Each string contains only lowercase Latin letters, its length is between 11 and 100100, inclusive.
Print nn lines, one line per a string in the input. The line should contain "Yes" if the corresponding string is diverse and "No" if the corresponding string is not diverse. You can print each letter in any case (upper or lower). For example, "YeS", "no" and "yES" are all acceptable.
8
fced
xyz
r
dabcef
az
aa
bad
babc
Yes
Yes
Yes
Yes
No
No
No
No
代码:
#include <bits/stdc++.h>
using namespace std; int N;
map<char, int> mp; int main() {
scanf("%d", &N);
getchar();
for(int i = ; i < N; i ++) {
mp.clear();
string s;
cin >> s;
bool flag = true;
int len = s.length();
int minn = ;
for(int j = ; j < len; j ++) {
mp[s[j]] ++;
minn = min(minn, s[j] - 'a');
if(mp[s[j]] > ) flag = false;
}
//printf("!!!%d\n", minn);
for(int j = minn; j < minn + len; j ++) {
if(mp[j + 'a'] == ) {
flag = false;
break;
}
}
if(flag) printf("Yes\n");
else printf("No\n");
}
return ;
}
B. Parity Alternated Deletions
Polycarp has an array aa consisting of nn integers.
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−1n−1 elements). For each of the next moves he chooses any element with the only restriction: its parity should differ from the parity of the element deleted on the previous move. In other words, he alternates parities (even-odd-even-odd-... or odd-even-odd-even-...) of the removed elements. Polycarp stops if he can't make a move.
Formally:
- If it is the first move, he chooses any element and deletes it;
- If it is the second or any next move:
- 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.
- If after some move Polycarp cannot make a move, the game ends.
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-deleted elements is zero.
Help Polycarp find this value.
The first line of the input contains one integer nn (1≤n≤20001≤n≤2000) — the number of elements of aa.
The second line of the input contains nn integers a1,a2,…,ana1,a2,…,an (0≤ai≤1060≤ai≤106), where aiai is the ii-th element of aa.
Print one integer — the minimum possible sum of non-deleted elements of the array after end of the game.
5
1 5 7 8 2
0
6
5 1 2 4 6 3
0
2
1000000 1000000
1000000
代码:
#include <bits/stdc++.h>
using namespace std; const int maxn = 1e5 + ;
int N;
int num[maxn];
vector<int> odd, even; int main() {
scanf("%d", &N);
for(int i = ; i < N; i ++) {
scanf("%d", &num[i]);
if(num[i] % ) odd.push_back(num[i]);
else even.push_back(num[i]);
}
int ans = ;
sort(odd.rbegin(), odd.rend());
sort(even.rbegin(), even.rend());
int osz = odd.size(), esz = even.size();
if(osz > esz + ) {
for(int i = esz + ; i < osz; i ++)
ans += odd[i];
}
else if(osz == esz + ) ans = ;
else {
for(int i = osz + ; i < esz; i ++)
ans += even[i];
}
printf("%d\n", ans);
return ;
}
standard output
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 [x1<x2<⋯<xk][x1<x2<⋯<xk]. And strictly decreasing sequence is a sequence of integers [y1>y2>⋯>yl][y1>y2>⋯>yl]. Note that the empty sequence and the sequence consisting of one element can be considered as increasing or decreasing.
They were merged into one sequence aa. After that sequence aa got shuffled. For example, some of the possible resulting sequences aa for an increasing sequence [1,3,4][1,3,4] and a decreasing sequence [10,4,2][10,4,2] are sequences [1,2,3,4,4,10][1,2,3,4,4,10] or [4,2,1,10,4,3][4,2,1,10,4,3].
This shuffled sequence aa is given in the input.
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 aa to increasing and decreasing sequences, print "NO".
The first line of the input contains one integer nn (1≤n≤2⋅1051≤n≤2⋅105) — the number of elements in aa.
The second line of the input contains nn integers a1,a2,…,ana1,a2,…,an (0≤ai≤2⋅1050≤ai≤2⋅105), where aiai is the ii-th element of aa.
If there is a contradiction in the input and it is impossible to split the given sequence aa to increasing and decreasing sequences, print "NO" in the first line.
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 nini — the number of elements in the strictly increasing sequence. nini can be zero, in this case the increasing sequence is empty.
In the third line print nini integers inc1,inc2,…,incniinc1,inc2,…,incni in the increasing order of its values (inc1<inc2<⋯<incniinc1<inc2<⋯<incni) — the strictly increasing sequence itself. You can keep this line empty if ni=0ni=0 (or just print the empty line).
In the fourth line print ndnd — the number of elements in the strictly decreasing sequence. ndnd can be zero, in this case the decreasing sequence is empty.
In the fifth line print ndnd integers dec1,dec2,…,decnddec1,dec2,…,decnd in the decreasing order of its values (dec1>dec2>⋯>decnddec1>dec2>⋯>decnd) — the strictly decreasing sequence itself. You can keep this line empty if nd=0nd=0 (or just print the empty line).
ni+ndni+nd should be equal to nn and the union of printed sequences should be a permutation of the given sequence (in case of "YES" answer).
7
7 2 7 3 3 1 4
YES
2
3 7
5
7 4 3 2 1
5
4 3 1 5 3
YES
1
3
4
5 4 3 1
5
1 1 2 1 2
NO
5
0 1 2 3 4
YES
0 5
4 3 2 1 0
代码:
#include <bits/stdc++.h>
using namespace std; const int maxn = 2e5 + ;
int N;
int a[maxn];
int vis[maxn]; int main() {
scanf("%d", &N);
bool flag = true;
for(int i = ; i < N; i ++) {
scanf("%d", &a[i]);
vis[a[i]] ++;
if(vis[a[i]] > ) flag = false;
}
if(!flag) {
printf("NO\n");
return ;
}
sort(a, a + N);
vector<int> up, down;
memset(vis, , sizeof(vis));
for(int i = ; i < N; i ++) {
if(!vis[a[i]]) {
up.push_back(a[i]);
vis[a[i]] = ;
} else down.push_back(a[i]);
}
printf("YES\n");
printf("%d\n", down.size());
if(down.size() == ) printf("\n");
else {
sort(down.begin(), down.end());
for(int i = ; i < down.size(); i ++)
printf("%d%s", down[i], i != down.size() - ? " " : "\n");
}
printf("%d\n", up.size());
if(up.size() == ) printf("\n");
else {
sort(up.rbegin(), up.rend());
for(int i = ; i < up.size(); i ++)
printf("%d%s", up[i], i != up.size() - ? " " : "\n");
}
return ;
}
standard output
You are given an array aa consisting of nn integers. You can perform the following operations arbitrary number of times (possibly, zero):
- Choose a pair of indices (i,j)(i,j) such that |i−j|=1|i−j|=1 (indices ii and jj are adjacent) and set ai:=ai+|ai−aj|ai:=ai+|ai−aj|;
- Choose a pair of indices (i,j)(i,j) such that |i−j|=1|i−j|=1 (indices ii and jj are adjacent) and set ai:=ai−|ai−aj|ai:=ai−|ai−aj|.
The value |x||x| means the absolute value of xx. For example, |4|=4|4|=4, |−3|=3|−3|=3.
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 10181018 by absolute value.
The first line of the input contains one integer nn (1≤n≤2⋅1051≤n≤2⋅105) — the number of elements in aa.
The second line of the input contains nn integers a1,a2,…,ana1,a2,…,an (0≤ai≤2⋅1050≤ai≤2⋅105), where aiai is the ii-th element of aa.
In the first line print one integer kk — the minimum number of operations required to obtain the array of equal elements.
In the next kk lines print operations itself. The pp-th operation should be printed as a triple of integers (tp,ip,jp)(tp,ip,jp), where tptp is either 11 or 22 (11means that you perform the operation of the first type, and 22 means that you perform the operation of the second type), and ipip and jpjp are indices of adjacent elements of the array such that 1≤ip,jp≤n1≤ip,jp≤n, |ip−jp|=1|ip−jp|=1. See the examples for better understanding.
Note that after each operation each element of the current array should not exceed 10181018 by absolute value.
If there are many possible answers, you can print any.
5
2 4 6 6 6
2
1 2 3
1 1 2
3
2 8 10
2
2 2 1
2 3 2
4
1 1 1 1
0
代码:
#include <bits/stdc++.h>
using namespace std; const int maxn = 2e5 + ;
int N;
int a[maxn], vis[maxn];
int st, en, maxx, cnt = ; int main() {
scanf("%d", &N);
for(int i = ; i <= N; i ++) {
scanf("%d", &a[i]);
vis[a[i]] ++;
if(vis[a[i]] > cnt) {
cnt = vis[a[i]];
maxx = a[i];
}
} for(int i = ; i < N; i ++) {
if(a[i] == maxx) {
st = i;
break;
}
} printf("%d\n", N - cnt);
if(N - cnt == ) return ;
for(int i = st; i >= ; i --) {
if(a[i] == maxx) continue;
else if(a[i] > maxx)
printf("2 %d %d\n", i, i + );
else printf("1 %d %d\n", i, i + );
}
for(int i = st; i <= N; i ++) {
if(a[i] == maxx) continue;
else if(a[i] < maxx)
printf("1 %d %d\n", i, i - );
else printf("2 %d %d\n", i, i - );
} return ;
}
You are given two strings ss and tt, both consisting of exactly kk lowercase Latin letters, ss is lexicographically less than tt.
Let's consider list of all strings consisting of exactly kk lowercase Latin letters, lexicographically not less than ss and not greater than tt(including ss and tt) in lexicographical order. For example, for k=2k=2, s=s="az" and t=t="bf" the list will be ["az", "ba", "bb", "bc", "bd", "be", "bf"].
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 ss and not greater than tt.
The first line of the input contains one integer kk (1≤k≤2⋅1051≤k≤2⋅105) — the length of strings.
The second line of the input contains one string ss consisting of exactly kk lowercase Latin letters.
The third line of the input contains one string tt consisting of exactly kk lowercase Latin letters.
It is guaranteed that ss is lexicographically less than tt.
It is guaranteed that there is an odd number of strings lexicographically not less than ss and not greater than tt.
Print one string consisting exactly of kk lowercase Latin letters — the median (the middle element) of list of strings of length kklexicographically not less than ss and not greater than tt.
2
az
bf
bc
5
afogk
asdji
alvuw
6
nijfvj
tvqhwp
qoztvz
代码:
#include <bits/stdc++.h>
using namespace std; const int maxn = 2e5 + ;
int N;
string s, t;
int ans[maxn]; /*string add(string a, string b) {
int len = a.length();
int upup = 0;
string sum = "";
for(int i = len - 1; i >= 0; i --) {
int na = a[i] - 'a';
int nb = b[i] - 'a';
int num = (na + nb) + upup;
if(num > 25) {
upup = 1;
num -= 26;
} else upup = 0;
sum += num + 'a';
}
if(upup) sum = "a" + sum;
return sum;
}*/ int main() {
scanf("%d", &N);
cin >> s >> t;
for(int i = N - ; i >= ; i --) {
int numa = s[i] - 'a';
int numb = t[i] - 'a';
ans[i] = numa + numb;
if(ans[i] % ) {
ans[i + ] += ;
ans[i] = (ans[i] - ) / ;
ans[i] += ans[i + ] / ;
ans[i + ] %= ;
}
else ans[i] = ans[i] / ;
} for(int i = ; i < N; i ++)
printf("%c", 'a' + ans[i]);
printf("\n"); return ;
}
模拟 26 进制加法
F. Graph Without Long Directed Paths
You are given a connected undirected graph consisting of nn vertices and mm edges. There are no self-loops or multiple edges in the given graph.
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).
The first line contains two integer numbers nn and mm (2≤n≤2⋅1052≤n≤2⋅105, n−1≤m≤2⋅105n−1≤m≤2⋅105) — the number of vertices and edges, respectively.
The following mm lines contain edges: edge ii is given as a pair of vertices uiui, vivi (1≤ui,vi≤n1≤ui,vi≤n, ui≠viui≠vi). There are no multiple edges in the given graph, i. e. for each pair (ui,viui,vi) there are no other pairs (ui,viui,vi) and (vi,uivi,ui) in the list of edges. It is also guaranteed that the given graph is connected (there is a path between any pair of vertex in the given graph).
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 mm. The ii-th element of this string should be '0' if the ii-th edge of the graph should be directed from uiui to vivi, and '1' otherwise. Edges are numbered in the order they are given in the input.
6 5
1 5
2 1
1 4
3 1
6 1
YES
10100
The picture corresponding to the first example:
And one of possible answers:
代码:
#include <bits/stdc++.h>
using namespace std; const int maxn = 2e5 + ;
int N, M;
int col[maxn], st[maxn], en[maxn];
vector<int> v[maxn];
bool flag = true; void dfs(int st, int fa, int color) {
col[st] = color;
if(v[st].size() == ) return;
for(int i = ; i < v[st].size(); i ++) {
if(v[st][i] == fa) continue;
if(col[v[st][i]] == -)
dfs(v[st][i], st, - color);
else if(col[v[st][i]] == col[st])
flag = false;
}
} int main() {
scanf("%d%d", &N, &M);
memset(col, -, sizeof(col));
for(int i = ; i < M; i ++) {
scanf("%d%d", &st[i], &en[i]);
v[st[i]].push_back(en[i]);
v[en[i]].push_back(st[i]);
}
flag = true;
dfs(, -, );
if(!flag) printf("NO\n");
else {
printf("YES\n");
for(int i = ; i < M; i ++) {
if(col[st[i]])
printf("");
else printf("");
}
} return ;
}
CodeForces Round #550 Div.3的更多相关文章
- Codeforces Round #550 (Div. 3) F. Graph Without Long Directed Paths
F. Graph Without Long Directed Paths time limit per test 2 seconds memory limit per test 256 ...
- D. Equalize Them All Codeforces Round #550 (Div. 3)
D. Equalize Them All time limit per test 2 seconds memory limit per test 256 megabytes input standar ...
- F. Graph Without Long Directed Paths Codeforces Round #550 (Div. 3)
F. Graph Without Long Directed Paths time limit per test 2 seconds memory limit per test 256 megabyt ...
- Codeforces Round #550 (Div. 3) E. Median String (模拟)
Median String time limit per test 2 seconds memory limit per test 256 megabytes input standard input ...
- (原创)Codeforces Round #550 (Div. 3) D. Equalize Them All
D. Equalize Them All time limit per test 2 seconds memory limit per test 256 megabytes input standar ...
- (原创)Codeforces Round #550 (Div. 3) A Diverse Strings
A. Diverse Strings time limit per test 1 second memory limit per test 256 megabytes input standard i ...
- Codeforces Round #550 (Div. 3)E. Median String
把字符串看作是26进制的数,从后往前翻译,那么就可以把两个串变成对应的26进制的数字,那么只要把两个数加起来除以二就得到中间的串对应的数了,同理再转化回来就行了.但是这样会有一个问题就是串的长度有2e ...
- Codeforces Round #550 (Div. 3) E. Median String (思维,模拟)
题意:给你两个字符串\(s\)和\(t\),保证\(t\)的字典序大于\(s\),求他们字典序中间的字符串. 题解:我们假设题目给的不是字符串,而是两个10禁止的正整数,那么输出他们之间的数只要把他两 ...
- Codeforces Round #550 (Div. 3) F. Graph Without Long Directed Paths (二分图染色)
题意:有\(n\)个点和\(m\)条无向边,现在让你给你这\(m\)条边赋方向,但是要满足任意一条边的路径都不能大于\(1\),问是否有满足条件的构造方向,如果有,输出一个二进制串,表示所给的边的方向 ...
随机推荐
- windows下数据库文件使用脚本同步到linux下的mysql数据库中
1.背景 windows server 2008 下 每天会有 *.sql数据文件 需要上传到linux 中的mysql数据库中 而运维人员是在 windows server 下使用 xshell 连 ...
- zabbix 添加自动发现端口并监控
最近在部署zabbix监控 有些服务器上开启的服务端口非常多 如果一个个添加监控会很繁琐,于是想到了自动发现规则 自动发现服务器上的服务端口并进行监控. 在zabbix客户端服务器上进行操作 1 ...
- Mac轻量级服务器http-server
刚想跑个Vue页面,发现我本地没有应用服务器(Tomcat/IIS...) 于是想下载了Tomcat,才发现我没有装JDK,而Mac的JDK下得好久,都下不下来,想想算了. 于是在网上找个轻量级的服务 ...
- hdfs fsck命令查看HDFS文件对应的文件块信息(Block)和位置信息(Locations)
关键字:hdfs fsck.block.locations 在HDFS中,提供了fsck命令,用于检查HDFS上文件和目录的健康状态.获取文件的block信息和位置信息等. fsck命令必须由HDFS ...
- 【HNOI2018】排列
[HNOI2018]排列 神仙贪心题. 题目说这么大堆东西就是想告诉你这是个森林,选了\(v\)的父亲后才能选\(v\). 我们设\(w_v\)为\(v\)所在联通块权值和,\(size_v\)表示\ ...
- Celery 异步任务
Celery https://www.cnblogs.com/DragonFire/p/10356615.html 介绍: Celery 是芹菜 Celery 是基于Python实现的模块, 用于执行 ...
- linux学习(杂项)
内存使用情况 磁盘使用情况 负载情况 查看cpu 可视化磁盘 循环创建文件夹 删除文件夹 移动文件 gg行首 G行尾 dd删除一行 u恢复 yy复制一行 p粘贴一行 enter下翻 less 与 mo ...
- Android中实现短信发送的一种方式
SendSmsActivity.java: package com.test.smsmangerdemo.sendsmsactivity; import android.support.v7.app. ...
- 【js】横/纵向无缝滚动
1.纵向无缝滚动(类似淘宝) ps:存在一个问题,当鼠标移入时,未关闭定时器 <!DOCTYPE html> <html> <head> <meta char ...
- 【angularjs】使用angular搭建项目,pc端实现网页中的内容不可复制
实现目标:不可复制页面内容 js: <script language="javascript"> if (typeof(document.onselectstart) ...