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 + 5;
char t[maxn];
vector<int>pos_of_vowel;
char vowel[5] = {'a', 'e', 'i', 'o', 'u'};

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

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

            }
        }
    }
    return 0;
}

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 = 0;
        if(x > a){
            ans += x - a;
        }
        if(y > b){
            ans += y - b;
        }
        if(z > c){
            ans += z - c;
        }
        printf("%d
", 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 + 5;
int num[maxn];
struct node{
    int num, cnt;
}se[1005];

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

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

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

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

题意：

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

思路：

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

#include <bits/stdc++.h>

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

int N;
char S[MAX_N];

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

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

    memset(can_jump, false, sizeof can_jump);
    for (int i = N+1; i <= 2*N; i++) {
        for (int j = 0; 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 = 0;
    for (int k = 1; k <= N-1; k++) {
        int g = gcd(k, N);
        if (can_jump[g])
            ans++;
    }
    cout << ans << endl;
    return 0;
}