2017-2018 ACM-ICPC Latin American Regional Programming Contest

题面pdfhttps://codeforc.es/gym/101889/attachments/download/7471/statements-2017-latam-regional.pdf

zyn感冒，两个人打。刚开始两题超迅速，40分钟后开始各种写不出，自闭。然后突然又开出两题。

4题全部1A，70名左右应该能稳个银。

说明卡题了可千万不能放弃！虽然可能简单题做不出来，过的多的题目做不出来，也不要放弃去开题。

以及周末这两场都说明一定要胆子大。

B---Buggy ICPC【找规律】

题意：

输入一串字符串，当遇到元音的时候前面输入的所有字符包括这个元音都反转一下。现在给定最后的结果字符串，问有多少种输入方法可以得到这个字符串。

思路：

czc去打了个表，然后我们疯狂找规律。真的找到规律了

如果没有元音，当然是1.如果有元音，但是第一个不是元音，一定是0

其他情况，答案就是中间两个元音之间的辅音个数$+1$。

只有一个元音时默认后面还有一个元音结尾，答案就是字符串长度。

 #include <bits/stdc++.h>

 using namespace std;

 const int maxn = 1e5 + ;
 char t[maxn];
 vector<int>pos_of_vowel;
 char vowel[] = {'a', 'e', 'i', 'o', 'u'};

 int main()
 {
     while(scanf("%s", t) != EOF){
         pos_of_vowel.clear();
         int len = strlen(t), cnt = ;
         for(int i = ; i < len; i++){
             for(int j = ; j < ; j++){
                 if(t[i] == vowel[j]){
                     cnt++;
                     pos_of_vowel.push_back(i);
                 }
             }
         }

         if(cnt == ){
             printf("1\n");
         }
         else{
             bool flag = false;
             for(int i = ; i < ; i++){
                 if(t[] == vowel[i]){
                     flag = true;
                     break;
                 }
             }
             if(!flag){
                 printf("0\n");
             }
             else{
                 if(cnt == ){
                     printf("%d\n", len);
                 }
                 else{
                     int id = (cnt + ) / ;
                     //cout<<id<<endl<<pos_of_vowel[id]<<endl<<pos_of_vowel[id - 1]<<endl;
                     int l = pos_of_vowel[id] - pos_of_vowel[id - ];
                     printf("%d\n", l);
                 }

             }
         }
     }
     return ;
 }

H---Hard Choice【水题】

题意：

【略】

思路：

【略】

 #include<iostream>
 //#include<bits/stdc++.h>
 #include<cstdio>
 #include<cmath>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<set>
 #include<climits>
 #include<map>
 using namespace std;
 typedef long long LL;
 #define N 100010
 #define pi 3.1415926535
 #define inf 0x3f3f3f3f

 int a, b, c;

 int main()
 {
     while(scanf("%d%d%d", &a, &b, &c) != EOF){
         int x, y, z;
         scanf("%d%d%d", &x, &y, &z);
         int ans = ;
         if(x > a){
             ans += x - a;
         }
         if(y > b){
             ans += y - b;
         }
         if(z > c){
             ans += z - c;
         }
         printf("%d\n", ans);
     }
 }

C---Complete Naebbirac's sequence【暴力】

题意：

有$n$个$1$到$k$之间的数。可以进行一下三种操作一次（只能一次）：1、删去其中一个。2、添加一个$1$到$k$的数。3、将其中一个换成另一个$1$到$k$的数。使得他们出现的次数都一样。

思路：

因为只能操作一次。所以每种操作都讨论一下就行了。

首先统计一下每个数出现的次数，按照次数从小到大排序。

1、把第一个数次数加1，看所有数是否满足次数相同。

2、把最后一个数次数减1，看所有数是否满足次数相同。

3、把第一个数次数加1，最后一个数次数减1，看所有数是否满足次数相同。

 #include<iostream>
 //#include<bits/stdc++.h>
 #include<cstdio>
 #include<cmath>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #include<set>
 #include<climits>
 #include<map>
 using namespace std;
 typedef long long LL;
 #define N 100010
 #define pi 3.1415926535
 #define inf 0x3f3f3f3f

 int n, k;
 const int maxn = 1e4 + ;
 int num[maxn];
 struct node{
     int num, cnt;
 }se[];

 bool cmp(node a, node b)
 {
     return a.cnt < b.cnt;
 }

 int main()
 {
     while(scanf("%d%d", &k, &n) != EOF){
         for(int i = ; i < ; i++){
             se[i].num = i;
             se[i].cnt = ;
         }
         for(int i = ; i < n; i++){
             scanf("%d", &num[i]);
             se[num[i]].cnt++;
         }

         sort(se + , se + k + , cmp);
         bool flag = true;
         se[].cnt++;
         for(int i = ; i <= k-; i++){
             if(se[i].cnt != se[i + ].cnt){
                 flag = false;
                 break;
             }
         }
         if(flag){
             printf("+%d\n", se[].num);
         }
         else{
             se[k].cnt--;
             bool flag2 = true;
             for(int i = ; i <= k - ; i++){
                 if(se[i].cnt != se[i + ].cnt){
                     flag2 = false;
                     break;
                 }
             }
             if(flag2){
                 printf("-%d +%d\n", se[k].num, se[].num);
             }
             else{
                 se[].cnt--;
                 bool flag3 = true;
                 for(int i = ; i <= k - ; i++){
                     if(se[i].cnt != se[i + ].cnt){
                         flag3 = false;
                         break;
                     }
                 }
                 if(flag3){
                     printf("-%d\n", se[k].num);
                 }
                 else{
                     printf("*\n");
                 }
             }
         }
     }
 }

J---Jumping Frog【数论】【环形dp】

题意：

有n个位子，有的是石头（R）， 有的是池塘（P）。青蛙只能在石头上跳，不能跳到池塘里去。每次他选择一个k，表示他每次跳k步，希望他可以跳回到起点。问以所有的位子为起点，一共能有多少种不同的k的选择。

思路：

这题是真的没思路。czc自己刷刷刷就敲完1A了。附一下他的代码。

 #include <bits/stdc++.h>

 using namespace std;
 const int MAX_N = 1e5 + ;

 int N;
 char S[MAX_N];

 vector <int> factor;
 void getFactors(int N)
 {
     factor.clear();
     for (int i = ; i <= N/i; i++) {
         if (N%i == ) {
             factor.push_back(i);
             if (i*i != N)
                 factor.push_back(N/i);
         }
     }
     sort(factor.begin(), factor.end());
 }

 bool f[MAX_N << ][];
 bool can_jump[MAX_N];
 void dp()
 {
     int cnt = factor.size();
     memset(f, false, sizeof f);
     for (int i = ; i <= *N; i++) {
         for (int j = ; j < cnt; j++) {
             int tmp = factor[j];
             if (S[(i-)%N] == 'P')
                 f[i][j] = false;
             else if (S[(i-)%N] == 'R') {
                 if (i-tmp <= )
                     f[i][j] = true;
                 else
                     f[i][j] = f[i-tmp][j];
             }
         }
     }

     memset(can_jump, false, sizeof can_jump);
     for (int i = N+; i <= *N; i++) {
         for (int j = ; j < cnt; j++) {
             int tmp = factor[j];
             if (f[i][j])
                 can_jump[tmp] = true;
         }
     }
 }

 inline int gcd(int a, int b)
 {
     return a%b ? gcd(b, a%b) : b;
 }

 int main()
 {
     scanf("%s", S);
     N = strlen(S);
     getFactors(N);
     dp();

     int ans = ;
     for (int k = ; k <= N-; k++) {
         int g = gcd(k, N);
         if (can_jump[g])
             ans++;
     }
     cout << ans << endl;
     return ;
 }