- C - Reorder the Array Codeforces Round #497 (Div. 2)
#include<iostream>
#include<map>
using namespace std;
map <int,int> m;
int n,maxn,a;
void solve(){
for(int i = 0;i < n;i++){
cin >> a;
m[a]++;
}
maxn = -1;
map <int,int> :: iterator it;
for(it = m.begin();it != m.end();it++){
if(it -> second > maxn) maxn = it -> second;
}
cout << n - maxn << '\n';
}
int main(){
cin >> n;
solve();
return 0;
}
这道题有一个方法需要我掌握，如何用map来得到数组中重复次数最多的数字（字符也行），并且在这里重新理清这道题的思路
首先这道题的大意就是给我们一个大小为n的整数数组，我们可以进行多次变换，使得变换后的数组中每个位置的数字尽可能比原来的数字大，求出最多能有几个数字能比原来的数字大。
思路呢大概就是如果单独一个数字的话，那么就是0，要是两个数字的话，那么最多只有两种不同的数组，而如果两个数字不一样的话，那么肯定有大小之分，而其中的一个数字必然比另一个小，那么就会导致最多有一个数字比原来的大。而如果是三个数字，假设三个数字都不同，如1 2 3 那么当数组为2 3 1时最大 但不管如何移动，1在数组里面都找不到一个位置使得它比原来的数字要大。而如果三个数字时有两个相同了，如1 1 2，那么不管这两个1怎么移动，都无法使得它比原来的数字大。所以能够猜测，就算数字都不相同，也至少有一个最小的数字无法比原来的数字要大，如果有n个相同的数字，那么就有n个数字无法比原来的大，比如1 2 2 最多就只能是 2 1 2或2 2 1了，有一个2怎么不可能比原来的数字大，再加上1也不行，那么答案就为3 - 2 = 1了，那么所有的情况也是如此，设有一个数字在数组中重复次数最多，为x，数组的大小为n，那么答案就为n - x。
而如何得到数组中重复次数最多的数字，最简单的方法就是使用map来得到，开一个map容器，然后每输入一个数字，就让该数字key的value++，最后从容器的头到尾遍历一遍寻找最大的数。
- Wonderful Coloring - 2 Codeforces Round #734 (Div. 3)
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 2e5 + 10;
int t,n,k,tim[maxn],col,ove,cul;
struct co{
int index,num,color;
}colo[maxn];
bool numcmp(co a,co b){
return a.num < b.num;
}
bool indcmp(co a,co b){
return a.index < b.index;
}
void solve(){
memset(tim,0,sizeof(tim));
cin >> n >> k;
col = 1;ove = 0;
for(int i = 0;i < n;i++){
cin >> colo[i].num;
colo[i].index = i;
tim[colo[i].num]++;
if(tim[colo[i].num] > k) colo[i].num = 0,colo[i].color = 0,ove++;
}
cul = n - ove;
//cout << cul << '\n';
sort(colo,colo + n,numcmp);
for(int i = 0;i < n;i++){
if(i > (n - (cul % k) - 1)){
// cout << (cul - (cul % k) - 1) << '\n';
colo[i].color = 0;
continue;
}
if(colo[i].num != 0){
colo[i].color = col++;
if(col > k) col = 1;
}
}
sort(colo,colo + n,indcmp);
for(int i = 0;i < n;i++) cout << colo[i].color << " ";
cout << '\n';
}
int main(){
cin >> t;
while(t--){
solve();
}
return 0;
}
这道题其实并不是非常难的，但一开始没有思路就开始硬做了，以后做题之前一定要好好思考下再做题，首先我们要考虑的是一个数字最多重复k次，如果超过k次的数字就让其变为0。之后我们要考虑的是如何让数字的颜色不重复，这个只需要一次排序就可以了。因为一个数字最多k次，如果我们让数字进行一个升序排序，那么重复数字就是连续的，这样的在赋予颜色的时候就不会出现重复的颜色了。最后再考虑每种颜色都是相同的，如果有n个数字，k种颜色，那么一个颜色最多就出现n/k次，那么多的那部分颜色呢？就直接将其变为0。
- C. Interesting Story Codeforces Round #734 (Div. 3)
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 2e5 + 10;
int t,n,temp,maxx;
string s;
int as,bs,cs,ds,es;
struct alp{
int a,b,c,d,e;
int am,bm,cm,dm,em;
int len;
}al[maxn];
bool acmp(alp a,alp b){
return a.am > b.am;
}
bool bcmp(alp a,alp b){
return a.bm > b.bm;
}
bool ccmp(alp a,alp b){
return a.cm > b.cm;
}
bool dcmp(alp a,alp b){
return a.dm > b.dm;
}
bool ecmp(alp a,alp b){
return a.em > b.em;
}
void solve(){
memset(al,0,sizeof(al));
cin >> n;
for(int i = 0;i < n;i++){
cin >> s;
al[i].len = s.size();
for(int j = 0;j < al[i].len;j++){
if(s[j] == 'a') al[i].a++;
if(s[j] == 'b') al[i].b++;
if(s[j] == 'c') al[i].c++;
if(s[j] == 'd') al[i].d++;
if(s[j] == 'e') al[i].e++;
}
al[i].am = al[i].a - al[i].len + al[i].a;
al[i].bm = al[i].b - al[i].len + al[i].b;
al[i].cm = al[i].c - al[i].len + al[i].c;
al[i].dm = al[i].d - al[i].len + al[i].d;
al[i].em = al[i].e - al[i].len + al[i].e;
//cout << al[i].a << " " << al[i].am << '\n';
}
as = bs = cs = ds = es = maxx = 0;
sort(al,al + n,acmp);temp = 0;
for(int i = 0;i < n;i++){
as += al[i].am;
if(as > 0) temp++;
else break;
}
if(temp > maxx) maxx = temp;
sort(al,al + n,bcmp);temp = 0;
for(int i = 0;i < n;i++){
bs += al[i].bm;
if(bs > 0) temp++;
else break;
}
if(temp > maxx) maxx = temp;
sort(al,al + n,ccmp);temp = 0;
for(int i = 0;i < n;i++){
cs += al[i].cm;
if(cs > 0) temp++;
else break;
}
if(temp > maxx) maxx = temp;
sort(al,al + n,dcmp);temp = 0;
for(int i = 0;i < n;i++){
ds += al[i].dm;
if(ds > 0) temp++;
else break;
}
if(temp > maxx) maxx = temp;
sort(al,al + n,ecmp);temp = 0;
for(int i = 0;i < n;i++){
es += al[i].em;
if(es > 0) temp++;
else break;
}
if(temp > maxx) maxx = temp;
cout << maxx << '\n';
}
int main(){
cin >> t;
while(t--){
solve();
}
return 0;
}
这道题我的做法巨麻烦，但也比较好理解，首先我先统计了每个单词中每个字母出现的次数，然后将其减去其他字母出现的次数，如果这个数是大于0的，那么这个字母的数量就比其他字母全部要多，最终将所有单词中这个字母出现的次数减其他字母出现的次数的值进行一个降序排序，一直想加这个值，如果这个值大于等于0那么就可以加上这个单词，只要碰到一次小于等于0的情况，那么后面的所有单词相加都会小于等于0，那么就到这里停止，这样一共重复五次，等到每个字母的。取其中最大的值即可，思路不难，就是重复的步骤太多了，显得十分的冗余。
- B. Minimum Ternary String Educational Codeforces Round 47 (Rated for Div. 2)
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 1e5 + 10;
string s;
int len,flag,vis[maxn],j;
char c[maxn];
void babo(int n){
int flag1 = 1;
while(flag1){
flag1 = 0;
for(int i = 0;i < n - 1;i++) if(s[i] > s[i + 1]) swap(s[i],s[i + 1]),flag1 = 1;
}
}
void solve(){
for(int i = j;i < len;i++){
if(s[i] == '1'){
vis[i] = 1;
cout << s[i];
}
}
for(int i = j;i < len;i++)
if(!vis[i]) cout << s[i];
}
int main(){
flag = 0;
memset(vis,0,sizeof(vis));
cin >> s;
len = s.size();
for(int i = 0;i < len;i++){
c[i] = s[i];
if(s[i] == '2'){
sort(c,c + i);
flag = 1;
for(j = 0;j < i;j++) cout << c[j];
break;
}
}
if(!flag){
sort(c,c + len);
for(int i = 0;i < len;i++) cout << c[i];
}
if(flag) solve();
return 0;
}
这道题的思路并不是很难想，因为1可以和所有字符交换，那么只要有1的就往前面扔，但是2和0不能交换所以我们需要保持2和0的相对位置不变。在找到第一个2之前，将前面的其他字符进行一个升序排序，在第一个2之后的所有1扔到这个2的前面，并且保持后面2和0的相对位置不变。这道题最简单的做法是，用一个cnt计住1的个数并将2和0扔到 另一个字符串中去，之后在这个字符串中寻找第一个2的位置并将cnt个1插入到这个2之前，所需要的函数为 ans.insert(pos + 1, string(cnt, ‘1’)); pos+1第一个2的位置，插入函数将会在pos + 1的位置之前插入string（cnt，‘1’），即cnt个1。复制n个c字符的函数为string（个数，字符）。其次string里面的字符并不能用sort进行排序。
- B. Running for Gold Codeforces Global Round 15
#include<iostream>
#include<algorithm>
using namespace std;
const int maxj = 5;
const int maxi = 5e4 + 10;
struct Rank{
int a[maxj];
}ath[maxi];
bool operator < (const Rank& A,const Rank& B){
int cnt = 0;
for(int i = 0;i < maxj;i++) cnt += (A.a[i] < B.a[i]);
return cnt >= 3;
}
void solve(){
int n;
cin >> n;
for(int i = 0;i < n;i++) for(int j = 0;j < maxj;j++) cin >> ath[i].a[j];
int gold = 0;
for(int i = 1;i < n;i++){
if(ath[i] < ath[gold]) gold = i;
}
for(int i = 0;i < n;i++){
if(i == gold) continue;
if(ath[i] < ath[gold]){
cout << -1 << '\n';
return;
}
}
cout << gold + 1 << '\n';
}
int main(){
int t;
cin >> t;
while(t--) solve();
return 0;
}
这道题并不能暴力去搜，那么我们就通过寻找当前最优秀的运动员，当所有循环一遍后，这个时候要么找到一位当前最优秀，要么就是没有一位最优秀的，将这一位优秀的按顺序和所有的运动员做一次比较，如果没有人比他更优秀了，那金牌就是他，如果能找出一位比他还要优秀，那么就产生矛盾了。比如1 比 2优秀 但1 没有 3优秀，这个时候最优秀的是3，但按顺序比较下来2 却比 3更优秀，那么就没有一位能够比其他所有运动员还要优秀的人，输出-1.
- A. Cherry Codeforces Round #735 (Div. 2)
#include<iostream>
using namespace std;
const int maxn = 1e5 + 10;
long long t,n,ans,arr[maxn];
int main(){
cin >> t;
while(t--){
ans = -1;
cin >> n;
for(int i = 0;i < n;i++){
cin >> arr[i];
}
for(int i = 0;i < n - 1;i++){
if(ans < arr[i] * arr[i + 1]) ans = arr[i] * arr[i + 1];
}
cout << ans << '\n';
}
}
这道题需要找的是一个区间内最大值和最小值的乘积，就相当于在找相邻数的乘积最大值，假设最左为5 最右为10 如果中间多个（5 - +无穷）的数，那么这个乘积的最大结果就只会在这个数到10出现，而不能包括5.如果多个（0-5）的数，那么最大的结果只会在5 - 10。所以求区间为3的最大值，就相当于求两个子区间为2中的最大值。如果区间为4的最大值，就是求子区间为3中的最大值，比如1 4 2 3，区间（4 2 3）是子区间为3中乘积最大的，（4,2）是子区间为2中乘积最大的。所以这个题不管区间多大，最终都能变成求子区间为2且连续的最大值。
- A. PizzaForces Educational Codeforces Round 112 (Rated for Div. 2)
#include<iostream>
using namespace std;
typedef long long ll;
ll t,n;
void solve(){
cin >> n;
if(n % 2 == 1) n++;
if(n <= 6){
cout << 15 << '\n';
return;
}
cout << n / 2 * 5 << '\n';
}
int main(){
cin >> t;
while(t--) solve();
return 0;
}
制作一个披萨的时候都是2.5min，而超过12的偶数都可以通过6,8,10的组合来实现，并且不会单独制作奇数的披萨，所以来13个人还是14个人，所需要的制作的披萨最短时间都是制作14个人的 即6 + 8的制作。如果来的人比6小 就输出制作6的时间，来的人数量比6大，如果是奇数就+1，是偶数就直接乘2.5min就好了
- B. Two Tables https://codeforces.com/contest/1555/problem/B
#include<bits/stdc++.h>
#define y1 h1
using namespace std;
const int INF = 0x3f3f3f3f;
int w,h,W,H,x1,x2,y1,y2,t;
void solve(){
cin >> W >> H;
cin >> x1 >> y1 >> x2 >> y2;
cin >> w >> h;
int ans = INF;
if(x2 - x1 + w <= W){
ans = min(ans,max(0,w - x1));
ans = min(ans,max(0,x2 - W + w));
}
if(y2 - y1 + h <= H){
ans = min(ans,max(0,h - y1));
ans = min(ans,max(0,y2 - H + h));
}
if(ans == INF){
cout << -1 << '\n';
return;
}
cout << fixed <<setprecision(9) << (double)ans << '\n';
}
int main(){
cin >> t;
while(t--){
solve();
}
return 0;
}
首先我们先放下一个桌子，再放第二个桌子的时候我们需要考虑，他们的宽或高是否超出了格子，如果他们的宽没有超过格子，我们就考虑左右平移的两种情况，第一张桌子向右移动dx的话，最少也需要给第二张桌子留下x1 +dx的距离来放置那么dx的取值就为0和w - x1的最大值；如果向左移动dx的话，那么右边至少要给第二张桌子留下W - x2 + dx的距离，即dx的取值为w - W + x2和0的最大值，ans即为两种移动方式的最小值。并且还有上下移动的两种类似的情况，四种情况取得的最小值就是最后的答案
- C. Coin Rows Educational Codeforces Round 112 (Rated for Div. 2)
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int t,mi[2][maxn],m,ans,max1,max2;
const int INF = 0x3f3f3f3f;
void solve(){
ans = INF;
for(int i = 0;i < m;i++) max1 += mi[0][i];
for(int i = 0;i < m;i++){
max1 -= mi[0][i];
ans = min(ans,max(max1,max2));
max2 += mi[1][i];
}
cout << ans << '\n';
}
int main(){
cin >> t;
while(t--){
cin >> m;
max1 = max2 = 0;
for(int i = 0;i <2;i++) for(int j = 0;j < m;j++) cin >> mi[i][j];
solve();
}
return 0;
}
本来以为是要用dp做的，但是没想到换个思路。alice不管怎么走，都只能将图形分为三种情况，要么一直往右走最后向下走第二行，除掉最后一个的前缀和就是bob的结果，要么先下走然后一直向右走除掉第一行开头的后缀和就是bob的结果，要么就是先向右做一段，然后向下走，再向右走，这样就会将结果分为第一行的后缀和和第二行的前缀和。因为我们的alice想要结果最小，那么她肯定要奔着最大的硬币格去走，bob想要最大的结果，那么也要奔着最大得到硬币格去走，按样例来看，三种情况分别为10,8，7/3,7/3中是因为bob的选择，bob肯定要选择最大的，所以是7,10,8,7是alice的选择，alice的选择是最小的，那么就只能选择7了。每次先减后缀和，最后再加前缀和，这样就可以模拟在哪里向下走bob能够得到的分数是最高的，ans会记录下这个过程中最小的值，因为每次都是alice做选择，bob能做的只是在alice选完后再看看选两条路的最大路走。
- A. Gregor and Cryptography Codeforces Round #736 (Div. 2)
#include<iostream>
using namespace std;
int t,p;
int main(){
cin >> t;
while(t--){
cin >> p;
cout << 2 << " " << p - 1 << '\n';
}
return 0;
}
要找到这两个a,b，那么是质数的话，那么一定mod 2 = 1，那么另外一个数就可以找mod ？ = 1的，而一个质数n mod n-1 的结果一定为1.
- B. Gregor and the Pawn Game Codeforces Round #736 (Div. 2)
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
string s1,s2;
int ans,vis[maxn],t,n;
void solve(){
ans = 0;
memset(vis,0,sizeof(vis));
for(int i = 0;i < n;i++){
if(s2[i] == '1'){
if(s1[i] == '0') ans++;
else if(s1[i - 1] == '1' && !vis[i - 1]) ans++,vis[i - 1] = 1;
else if(s1[i + 1] == '1' && !vis[i + 1]) ans++,vis[i + 1] = 1;
}
}
cout << ans << '\n';
}
int main(){
cin >> t;
while(t--){
cin >> n;
cin >> s1;
cin >> s2;
solve();
}
return 0;
}
很简单的一道贪心，主要是题目一直看不懂咳咳。如果最后一列是1，那么就先往上走，如果是0就直走，如果是1那么先往左再往右，往左的时候要看这个位置是不是1和有没有我们的棋子了，并且不能超过范围，如果有一个不满足就向右走，向右肯定没有我们的棋子只要不超过范围并且这个位置是1，就向右走。
- C. Web of Lies Codeforces Round #736 (Div. 2)
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n,m,vis[maxn],q,q1,u,v,ans;
int main(){
cin >> n >> m;
for(int i = 1;i <= m;i++){
cin >> u >> v;
if(u > v) swap(u,v);
if(!vis[u]) ans++;
vis[u]++;
}
cin >> q;
while(q--){
cin >> q1;
if(q1 == 1){
cin >> u >> v;
if(u > v) swap(u,v);
if(!vis[u]) ans++;
vis[u]++;
}
if(q1 == 2){
cin >> u >> v;
if(u > v) swap(u,v);
vis[u]--;
if(!vis[u]) ans--;
}
if(q1 == 3){
cout << n - ans << '\n';
}
}
return 0;
}
这道题一开始题目读错了就很头痛，而且前一种方法一直超时，那么就选择这一种。如果一个小贵族和一个大贵族连在了一起，那么这个小贵族必死，如果这个时候小贵族是活着的就让ans++并且让他死一次，如果取消了一个小贵族和一个大贵族的联系，先让小贵族复活一次如果复活后的小贵族刚好把死的次数抵消了，那么就让ans–代表小贵族活过来了。最后输出人数-ans就是最终活下来的贵族。每次杀完贵族后并不清空他们的关系，即保持原样（题目读半天实在是读不懂）
- A. Death Note Educational Codeforces Round 48 (Rated for Div. 2)
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long n,m,a[maxn],cur,sum;
int main(){
cur = sum = 0;
cin >> n >> m;
for(int i = 0;i < n;i++){
cin >> a[i];sum += a[i];
cout << sum / m - cur << " ";
cur += sum / m - cur;
}
return 0;
}
题目是非常简单的，主要是注意下开longlong 连续交几次都错了因为忘记开ll了，一定要记住看数据的范围
- B. Segment Occurrences Educational Codeforces Round 48 (Rated for Div. 2)
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int n,m,q,l,r,pr[maxn];
bool ok[maxn],flag;
string s,t;
int main(){
cin >> n >> m >> q;
cin >> s >> t;
pr[0] = 0;
for(int i = 0;i < n - m + 1;i++){
flag = true;
for(int j = 0;j < m;j++)
if(s[i + j] != t[j]){
flag = false;
break;
}
ok[i] = flag;
pr[i + 1] = pr[i] + ok[i];
}
for(int i = max(0,n - m + 1);i < n;i++){
pr[i + 1] = pr[i];
}
while(q--){
cin >> l >> r;
l--,r -= m - 1;
cout << (r >= l ? (pr[r] - pr[l]) : 0) << '\n';
}
return 0;
}
这个题很适合我，一开始想了很多奇奇怪怪的方法都不大行，因为很容易超时。首先我们在大小为n的字符串中，含有m个字符的连续子串最多就只能有n - m + 1个，那么我们所要找的字符串的个数也就这么多。我们从第一个位置i = 0开始，如果从这个位置到m + i和我们要找的字符串每个字符都相等，就让flag = 1不然就为0，这样可以把第一个字符串遍历一遍，因为左右区间是从1开始的，而我们是从0开始的，它们之间就相差了1，所以数组在计数的时候也要加上1，我们就让pr【i + 1】 = pr[i] + ok[i]。pr是前缀和数组，代表的是这个位置之前一共有几个这样的字符串，如果当前位置也有这个字符串的话，就让pr[i + 1] 等于之前位置的字符串个数加上当前位置的。遍历完一遍后，我们就让后面无法遍历的位置的那些前缀和数组都变成前一个位置的前缀和，因为长度都不够了就绝对不会再有新的字符串出现了。这样的时间复杂度为n*m。最后通过q次查询，每次给出左右端点，给出左端点我们就让l–，因为我们pr数组代表的从一开始到该位置有的字符串个数，我们要忽略掉该位置的，就是这个位置之前有多少个，即代表旧的个数，让r -= m - 1，是因为我们只查到r，我们只要到从第二个字符串个数的长度到r就可以了，留下m个位置就可以了。如果r 在 l 左边了，就说明这个区间的长度太小了，输出0。如果正常的话，就用r这个位置前缀和减去l之前一个位置的前缀和，因为这个区间内有字符串个数应该为新的个数-旧的个数
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int q,n,r,point[maxn],ans;
int main(){
cin >> q;
while(q--){
ans = 0;
cin >> n >> r;
for(int i = 0;i < n;i++) cin >> point[i];
sort(point,point + n);
n = unique(point,point + n) - point;
for(int i = n - 1;i >= 0;i--) ans += (point[i] - ans * r > 0);
cout << ans << '\n';
}
return 0;
}
***这个题用到了一个新的函数：unique，它可以去掉数组中重复的元素，将重复的拿到容器的末尾，最后返回的是无重复项的尾地址。就比如a[5] = 1 2 2 3 4 5 unique（a,a + n）就会得到1 2 3 4 5.想要知道里面有多少个不重复的数字就需要n = unique（a ,a + n） - a。就是用尾地址减去首地址得到的。***而这道题我们只需要贪心的从后面开始炸，遍历一遍，每个怪物都要受到爆炸，一开始不炸，ans为0，最后一个怪物移动ans * r，因为不能被推到左边选择被直接炸死，ans++。倒数第二个怪物要是受到前面一个爆炸没有被推到左边去，就继续炸。直到前面有怪物位移ans * r后到了左边。
94
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
