Codeforces Round #598 (Div. 3)
比賽傳送門
A - Payment Without Change
Problem Description
You have a coins of value n and b coins of value 1. You always pay in exact change, so you want to know if there exist such x and y that if you take x (0≤x≤a) coins of value n and y (0≤y≤b) coins of value 1, then the total value of taken coins will be S.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1≤q≤10e4) — the number of test cases. Then q test cases follow.
The only line of the test case contains four integers a, b, n and S (1≤a,b,n,S≤10e9) — the number of coins of value n, the number of coins of value 1, the value n and the required total value.
Output
For the i-th test case print the answer on it — YES (without quotes) if there exist such x and y that if you take x coins of value n and y coins of value 1, then the total value of taken coins will be S, and NO otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES will all be recognized as positive answer).
Example
input
4
1 2 3 4
1 2 3 6
5 2 6 27
3 3 5 18
output
YES
NO
NO
YES
Code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int a,b,n,s;
scanf("%d%d%d%d",&a,&b,&n,&s);
int need=s/n;
int mon=0;
if(need<=a)
mon=n*need;
else
mon=n*a;
if(s-mon<=b)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
return 0;
}
B - Minimize the Permutation
Problem Description
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n−1 operations with the given permutation (it is possible that you don’t perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let’s consider the permutation [5,4,1,3,2]. The minimum possible permutation we can obtain is [1,5,2,4,3] and we can do it in the following way:
perform the second operation (swap the second and the third elements) and obtain the permutation [5,1,4,3,2];
perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5,1,4,2,3];
perform the third operation (swap the third and the fourth elements) and obtain the permutation [5,1,2,4,3].
perform the first operation (swap the first and the second elements) and obtain the permutation [1,5,2,4,3];
Another example is [1,2,4,3]. The minimum possible permutation we can obtain is [1,2,3,4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1≤q≤100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1≤n≤100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i≤n that for all j from 1 to i−1 the condition pj=qj is satisfied, and pi<qi. For example:
p=[1,3,5,2,4] is less than q=[1,3,5,4,2] (such i=4 exists, that pi<qi and for each j<i holds pj=qj),
p=[1,2] is less than q=[2,1] (such i=1 exists, that pi<qi and for each j<i holds pj=qj).
Code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
const int N=105;
int num[N];
int vis[N];
void init()
{
memset(vis,0,sizeof(vis));
vis[0]=1;
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
init();
int n;
scanf("%d",&n);
rep(i,1,n)
{
scanf("%d",&num[i]);
}
int cnt=0;
int minn=1;
while(cnt<n-1&&minn!=n+1)
{
int p=1;
rep(i,1,n)
{
if(num[i]==minn)
{
p=i;
break;
}
}
while(vis[p-1]==0&&num[p-1]>num[p])
{
swap(num[p],num[p-1]);
vis[p-1]=1;
cnt++;
p--;
}
minn++;
}
rep(i,1,n)
{
printf("%d ",num[i]);
}
printf("\n");
}
return 0;
}
C - Platforms Jumping
Problem Description
There is a river of width n. The left bank of the river is cell 0 and the right bank is cell n+1 (more formally, the river can be represented as a sequence of n+2 cells numbered from 0 to n+1). There are also m wooden platforms on a river, the i-th platform has length ci (so the i-th platform takes ci consecutive cells of the river). It is guaranteed that the sum of lengths of platforms does not exceed n.
You are standing at 0 and want to reach n+1 somehow. If you are standing at the position x, you can jump to any position in the range [x+1;x+d]. However you don’t really like the water so you can jump only to such cells that belong to some wooden platform. For example, if d=1, you can jump only to the next position (if it belongs to the wooden platform). You can assume that cells 0 and n+1 belong to wooden platforms.
You want to know if it is possible to reach n+1 from 0 if you can move any platform to the left or to the right arbitrary number of times (possibly, zero) as long as they do not intersect each other (but two platforms can touch each other). It also means that you cannot change the relative order of platforms.
Note that you should move platforms until you start jumping (in other words, you first move the platforms and then start jumping).
For example, if n=7, m=3, d=2 and c=[1,2,1], then one of the ways to reach 8 from 0 is follow:
The first example: n=7.
Input
The first line of the input contains three integers n, m and d (1≤n,m,d≤1000,m≤n) — the width of the river, the number of platforms and the maximum distance of your jump, correspondingly.
The second line of the input contains m integers c1,c2,…,cm (1≤ci≤n,∑i=1mci≤n), where ci is the length of the i-th platform.
Output
If it is impossible to reach n+1 from 0, print NO in the first line. Otherwise, print YES in the first line and the array a of length n in the second line — the sequence of river cells (excluding cell 0 and cell n+1).
If the cell i does not belong to any platform, ai should be 0. Otherwise, it should be equal to the index of the platform (1-indexed, platforms are numbered from 1 to m in order of input) to which the cell i belongs.
Note that all ai equal to 1 should form a contiguous subsegment of the array a of length c1, all ai equal to 2 should form a contiguous subsegment of the array a of length c2, …, all ai equal to m should form a contiguous subsegment of the array a of length cm. The leftmost position of 2 in a should be greater than the rightmost position of 1, the leftmost position of 3 in a should be greater than the rightmost position of 2, …, the leftmost position of m in a should be greater than the rightmost position of m−1.
See example outputs for better understanding.
Examples
input
7 3 2
1 2 1
output
YES
0 1 0 2 2 0 3
input
10 1 11
1
output
YES
0 0 0 0 0 0 0 0 0 1
input
10 1 5
2
output
YES
0 0 0 0 1 1 0 0 0 0
Note
Consider the first example: the answer is [0,1,0,2,2,0,3]. The sequence of jumps you perform is 0→2→4→5→7→8.
Consider the second example: it does not matter how to place the platform because you always can jump from 0 to 11.
Consider the third example: the answer is [0,0,0,0,1,1,0,0,0,0]. The sequence of jumps you perform is 0→5→6→11.
Code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
const int N=1005;
int a[N];
int ans[N];
int main()
{
int n,m,d;
scanf("%d%d%d",&n,&m,&d);
int sum=0;
rep(i,1,m)
{
scanf("%d",&a[i]);
sum+=a[i];
}
int p=d;
int cnt=1;
while(p<=n-sum&&cnt<=m)
{
rep(i,0,a[cnt]-1)
{
ans[p+i]=cnt;
}
sum-=a[cnt];
p+=d+a[cnt]-1;
cnt++;
}
if(cnt==m+1&&p<=n)
{
printf("NO\n");
return 0;
}
printf("YES\n");
int pos=n;
per(i,m,cnt)
{
rep(j,0,a[i]-1)
{
ans[pos--]=i;
}
}
rep(i,1,n)
{
printf("%d ",ans[i]);
}
printf("\n");
return 0;
}
D - Binary String Minimizing
Problem Description
You are given a binary string of length n (i. e. a string consisting of n characters ‘0’ and ‘1’).
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1≤q≤104) — the number of test cases.
The first line of the test case contains two integers n and k (1≤n≤106,1≤k≤n2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters ‘0’ and ‘1’.
It is guaranteed that the sum of n over all test cases does not exceed 106 (∑n≤106).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
input
3
8 5
11011010
7 9
1111100
7 11
1111100
output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 
In the third example, there are enough operations to make the string sorted.
Code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
const int N=1e6+5;
char str[N];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int n;
ll k;
scanf("%d%I64d",&n,&k);
scanf("%s",str+1);
int zero=0;
rep(i,1,n)
{
if(str[i]=='0')
{
if(k<i-zero-1)
{
swap(str[i],str[i-k]);
break;
}
else
{
swap(str[i],str[zero+1]);
k-=i-zero-1;
zero++;
}
}
}
printf("%s\n",str+1);
}
return 0;
}
E - Yet Another Division Into Teams
Problem Description
There are n students at your university. The programming skill of the i-th student is ai. As a coach, you want to divide them into teams to prepare them for the upcoming ICPC finals. Just imagine how good this university is if it has 2⋅105 students ready for the finals!
Each team should consist of at least three students. Each student should belong to exactly one team. The diversity of a team is the difference between the maximum programming skill of some student that belongs to this team and the minimum programming skill of some student that belongs to this team (in other words, if the team consists of k students with programming skills a[i1],a[i2],…,a[ik], then the diversity of this team is maxj=1ka[ij]−minj=1ka[ij]).
The total diversity is the sum of diversities of all teams formed.
Your task is to minimize the total diversity of the division of students and find the optimal way to divide the students.
Input
The first line of the input contains one integer n (3≤n≤2⋅105) — the number of students.
The second line of the input contains n integers a1,a2,…,an (1≤ai≤109), where ai is the programming skill of the i-th student.
Output
In the first line print two integers res and k — the minimum total diversity of the division of students and the number of teams in your division, correspondingly.
In the second line print n integers t1,t2,…,tn (1≤ti≤k), where ti is the number of team to which the i-th student belong.
If there are multiple answers, you can print any. Note that you don’t need to minimize the number of teams. Each team should consist of at least three students.
Examples
input
5
1 1 3 4 2
output
3 1
1 1 1 1 1
input
6
1 5 12 13 2 15
output
7 2
2 2 1 1 2 1
input
10
1 2 5 129 185 581 1041 1909 1580 8150
output
7486 3
3 3 3 2 2 2 2 1 1 1
Note
In the first example, there is only one team with skills [1,1,2,3,4] so the answer is 3. It can be shown that you cannot achieve a better answer.
In the second example, there are two teams with skills [1,2,5] and [12,13,15] so the answer is 4+3=7.
In the third example, there are three teams with skills [1,2,5], [129,185,581,1041] and [1580,1909,8150] so the answer is 4+912+6570=7486.
題意
給定n個人的能力值，每個人有一個能力值，整個隊伍的一個我也不知道叫啥的值爲一個隊伍裏最大能力值減最小能力值，一支隊最少三人，問最下的能力值之和是多少。
思路
我們可以發現，每支隊伍的人數只能爲3、4、5，所以我們可以直接dp求解。
然後dp的同時用一個last數組記錄這個dp值是由那個dp值傳過來的，即可記錄路徑。
坑點
反正我是沒想到每個隊伍的人數只能爲3、4、5。
Code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
const int N=2e5+5;
struct S
{
int num;
int id;
int team;
} peo[N];
bool cmp_num(S aa,S bb)
{
return aa.num<bb.num;
}
bool cmp_id(S aa,S bb)
{
return aa.id<bb.id;
}
int last[N];
int dp[N];
int main()
{
int n;
scanf("%d",&n);
ll sum=0;
rep(i,1,n)
{
scanf("%d",&peo[i].num);
peo[i].id=i;
}
sort(peo+1,peo+1+n,cmp_num);
sum=peo[n].num-peo[1].num;
if(n<=5)
{
printf("%d %d\n",peo[n].num-peo[1].num,1);
rep(i,1,n)
{
printf("1 ");
}
printf("\n");
return 0;
}
rep(i,0,n)
{
dp[i]=sum;
}
last[0]=-1;
dp[0]=INT_MAX;
dp[1]=INT_MAX;
dp[2]=INT_MAX;
dp[3]-=peo[4].num-peo[3].num;
last[3]=0;
dp[4]-=peo[5].num-peo[4].num;
last[4]=0;
dp[5]-=peo[6].num-peo[5].num;
last[5]=0;
peo[n+1].num=peo[n].num;
rep(i,6,n)
{
int p=i-3;
int minn=0x3f3f3f3f;
if(dp[i-3]<dp[i-4])
{
minn=dp[i-3];
p=i-3;
}
else
{
minn=dp[i-4];
p=i-4;
}
if(dp[i-5]<minn)
{
minn=dp[i-5];
p=i-5;
}
dp[i]=minn-(peo[i+1].num-peo[i].num);
last[i]=p;
}
int cnt=1;
int pos=n;
while(last[pos]!=-1)
{
peo[pos].team=cnt;
cnt++;
pos=last[pos];
}
int cntt=0;
per(i,n,1)
{
if(peo[i].team==0)
{
peo[i].team=cntt;
}
else
{
cntt=peo[i].team;
}
}
sort(peo+1,peo+1+n,cmp_id);
printf("%d %d\n",dp[n],cntt);
rep(i,1,n)
{
printf("%d ",peo[i].team);
}
printf("\n");
return 0;
}
F - Equalizing Two Strings
Problem Description
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
Choose any contiguous substring of the string s of length len and reverse it;
at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1…3] and t[3…5], s[2…4] and t[2…4], but not s[1…3] and t[1…2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1≤q≤104) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1≤n≤2⋅105) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2⋅105 (∑n≤2⋅105).
Output
For each test case, print the answer on it — “YES” (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and “NO” otherwise.
Example
input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
output
NO
YES
NO
YES
題意
給定兩個長度爲n的串s和t，每次操作可以在s和t中分別選擇長度相同（位置可以不同）的串進行反轉操作，問能不能在若干次操作之後，使得兩個串完全相同。
思路
1.如果兩個串中各個字符出現的次數不同，輸出NO
2.如果兩個串中某個字符出現的次數大於等於2，輸出YES。
3.如果兩個串中逆序對的個數的奇偶性不同輸出NO，否則輸出YES。
詳解：
2.如果兩個串中某個字符出現的次數大於等於2，我們可以先將這個字符全部移到串的最前端，然後一個串始終調換這兩個相同的字符，後面的字符按照冒泡排序的方法跟另一個串對比排好即可。
3.一個串中選擇長度爲len的串進行反轉之後，串的逆序對的個數的奇偶性不變。如果奇偶性相同，一個串始終反轉某兩個字符，另一個串按照冒泡排序的方式對比排好即可。
坑點
一開始以爲是O(n2)的複雜度，然鵝n是2e5啊，4e10了啊,CF再牛逼1s也不能1e10吧。
但是！
經過第2條的篩選之後，剩下的串每個字符出現的次數最多隻有一次，也就是說字符串的長度最長爲26，O(n2）的複雜度最壞情況就是O(262)。。。
所以這樣並沒有什麼毛病，複雜度還挺低。
Code
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
const int N = 2e5+5;
char str1[N],str2[N];
int vis1[30],vis2[30];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
memset(vis1,0,sizeof(vis1));
memset(vis2,0,sizeof(vis2));
int n;
scanf("%d",&n);
scanf("%s%s",str1+1,str2+1);
int flag=-1;
rep(i,1,n)
{
vis1[str1[i]-'a']++;
vis2[str2[i]-'a']++;
}
rep(i,0,28)
{
if(vis1[i]!=vis2[i])
flag=0;
}
if(flag==0)
{
printf("NO\n");
continue;
}
rep(i,0,28)
{
if(vis1[i]>=2)
flag=1;
}
if(flag==1)
{
printf("YES\n");
continue;
}
int cnt1=0,cnt2=0;
rep(i,1,n)
{
rep(j,i,n)
{
if(str1[i]>str1[j])
cnt1++;
if(str2[i]>str2[j])
cnt2++;
}
}
if(cnt1%2==cnt2%2)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
