xdoj 2018校赛 现场赛

发挥不是太好，感觉这次校赛难度挺大的，主要是最后的三道题难度有点高（也可能是自己太菜）。忘了考校赛的题干，所以只能先把前七题写一下，后三题估计要研究一阵，而且每一道都够写一篇文章的了（可能会写在难题集里）。

A
这次就连水题都这么难吗？再加上题干输出部分出了问题坑了我一会（我不会告诉你是我英文的九写错了）。

贴代码

# include <string.h>
# include <stdio.h>
# include <algorithm>

using namespace std;

int main()
{
    int T;
    scanf("%d", &T);

    char s[30];

    while(T--)
    {
        scanf("%s", s);
        if(!strcmp(s , "zero"))
            printf("ling\n");
        else if(!strcmp(s , "one"))
            printf("yi\n");
        else if(!strcmp(s , "two"))
            printf("er\n"); 
        else if(!strcmp(s , "three"))
            printf("san\n");
        else if(!strcmp(s , "four"))
            printf("si\n");
        else if(!strcmp(s , "five"))
            printf("wu\n"); 
        else if(!strcmp(s , "six"))
            printf("liu\n");
        else if(!strcmp(s , "seven"))
            printf("qi\n");
        else if(!strcmp(s , "eight"))
            printf("ba\n");
        else if(!strcmp(s , "nine"))
            printf("jiu\n");    
        else if(!strcmp(s , "ten"))
            printf("shi\n");        
    }

    return 0;
}

B
读了两遍明白了（今年的比2017年的不友好多了）随便写写即可
（特别备注，这道题升级了数据，导致之前的代码用不了了，这里已经做了更新 5/10/2018）

贴代码

# include <stdio.h>
# include <string.h>

inline int max(int a , int b)
{
    return (a > b) ? a : b;
}

int main()
{
    char s[30], c[30];
    int n[26];
    int m[26];

    while(~scanf("%s", s))
    {
        memset(n , 0 , sizeof(n));

        int i, j;
        for(i = 0 ; s[i] ; i++)
            n[s[i] - 'a']++;

        int N;
        scanf("%d", &N);

        int ans = 0;
        for(i = 0 ; i < N ; i++)
        {
            memset(m , 0 , sizeof(m));
            scanf("%s", c);

            for(j = 0 ; c[j] ; j++)
            {
                m[c[j] - 'a']++;
                if(m[c[j] - 'a'] > n[c[j] - 'a'])
                    break;
            }
            if(!c[j])
            ans = max(ans , j);
        } 

        printf("%d\n", ans);
    } 

    return 0;
}

C
稍稍推一下就知道最后那个组里面会有i - 1张第i大的数字，一个一个数即可。

贴代码

# include <stdio.h>
# include <algorithm>

using namespace std;

const int MAX_N = 2500;

int A[MAX_N];

int main()
{
    int T;
    int N, K;
    scanf("%d", &T);

    while(T--)
    {
        scanf("%d %d", &N, &K);

        int i;
        for(i = 0 ; i < N ; i++)
            scanf("%d", &A[i]);

        sort(A , A + N);
        for(i = 1 ; i < N ; i++)
        {
            if(K <= i)
            {
                printf("%d\n", A[N - 1 - i]);
                break;
            }
            K -= i;
        }
    }

    return 0;
}

D
哲学题，题干已经提示得很明显了，没有任何一个值是独特的，所以必然是平均值。

贴代码

# include <stdio.h>
# include <algorithm>

using namespace std;

int main()
{
    int T;
    scanf("%d", &T);

    while(T--)
    {
        int N;
        int sum = 0;
        int t;
        scanf("%d", &N);
        int i;
        for(i = 0 ; i < N ; i++)
        {
            scanf("%d", &t);
            sum += t;
        }
        printf("%d\n", sum / N);
    }


    return 0;
}

E
跟xdoj里的1113 Too Light差不多，算是那道题的弱化版。一个递推既可以搞定，考虑以i结尾除3余i的有多少即可。

贴代码

# include <stdio.h>
# include <algorithm>
# include <string.h>

using namespace std;

typedef long long ll;

const int MAX_N = 1e6;

char s[MAX_N + 10];
ll dp[2][3];

int main()
{
    while(~scanf("%s", s))
    {
        memset(dp , 0 , sizeof(dp));

        ll ans = 0;

        ll * now = dp[0], * next = dp[1];

        int i, j;
        for(i = 0 ; s[i] ; i++)
        {
            now[0]++;
            next[0] = next[1] = next[2] = 0;
            for(j = 0 ; j < 3 ; j++)
            {
                next[(j * 2 + s[i] - 48) % 3] += now[j];
            }
            ans += next[0];
            swap(now , next);
        }
        printf("%lld\n", ans);
    }


    return 0;
}

F
又是哲学题，随便瞎蒙了一个算法就写了，结果竟然一遍过，神奇。
我的算法可以认为是一个贪心，每次如果要踢人就踢掉之后出现次数最少的那个，这样用一个set来维护即可。

贴代码

# include <stdio.h>
# include <algorithm>
# include <set>

using namespace std;

typedef pair<int , int> P;

const int MAX_N = 1e5;

int A[MAX_N + 1];
int B[MAX_N + 1];

int main()
{
    int N, M, Q;
    while(~scanf("%d %d %d", &N, &M, &Q))
    {
        fill(A , A + M + 1 , 0);
        int i;
        for(i = 0 ; i < Q ; i++)
        {
            scanf("%d", &B[i]);
            A[B[i]]++;
        }
        set<P> s;
        int num = 0;

        bool ok[MAX_N + 1] = {0};

        int ans = 0;
        for(i = 0 ; i < Q ; i++)
        {
            if(!ok[B[i]])
            {
                A[B[i]]--;
                ans++;
                ok[B[i]] = 1;
                if(num < M)
                {
                    s.insert(P(A[B[i]] , B[i]));
                }
                else
                {
                    ok[(*s.begin()).second] = 0;
                    s.erase(*s.begin());
                    s.insert(P(A[B[i]] , B[i]));
                }
            }
            else
            {
                s.erase(P(A[B[i]] , B[i]));
                A[B[i]]--;
                s.insert(P(A[B[i]] , B[i]));        
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}

G
因为n的值太大了所以可以排除一切笨办法，包括递归和搜索，那就只能找规律题，先用笨办法打出前一百个的值，干瞪眼法瞪了一会儿之后发现只要把每个素因子减一相加（我也不知道为什么，完全是看出来的），所以只要打一个1000的素数表就行了。

贴代码

# include <stdio.h>
# include <algorithm>
# include <queue>

using namespace std;

int N, T;

int p[1000], num;
bool used[1001];

void pri(int n)
{
    num = 0;

    used[0] = used[1] = 1;

    int i, j;
    for(i = 2 ; i <= n ; i++)
    {
        if(!used[i])    
            p[num++] = i;

        for(j = 0 ; j < num && i * p[j] < n ; j++)
        {
            used[i * p[j]] = 1;
            if(i % p[j] == 0) 
                break;
        }
    }
}

void solve()
{
    int i;
    int ans = 0;
    for(i = 0 ; i < num && N > 1 ; i++)
    {
        while(N % p[i] == 0)
        {
            N /= p[i];
            ans += p[i] - 1;
        }
    }

    ans += N - 1;
    printf("%d\n", ans);
}

int main()
{
    pri(1000);

    scanf("%d", &T);

    while(T--)
    {
        scanf("%d", &N);

        solve();
    } 

    return 0;
}

至于后三题先简单说说当前的想法吧
H
最难的一道，没有人做出来，我的初始想法就是一个状压dp，然后再用一下快速幂，结果这么搞完之后才发现一个致命的问题，就是这个环有很严重的重复问题，这个减少的个数和循环节有关，相当于每种情况应当除以循环节的长度，这样这题就变成了一个很复杂的因式分解和容斥问题，就很难解决了，鉴于这个巨大的n，所以肯定要用到快速幂，那么怎么改要么就是递推式的优化，要么就是很高明的容斥了，反正我还在思考。

I
一道让我发疯的题，感觉大体知道怎么做但是就是没有读懂题目具体的意思，总之那个示例的值是死活凑不出来，不过这道题十之八九是考的线段树，不只是线段树元素之和，还包括平方之和，当然这个是可以解决的，我当时就想到了，维护三个值，初始元素之和，初始元素平方之和，以及当前线段元素全部加的数，这三个足以算出当前平方和了，不过没读懂具体的意思的确是有点遗憾。

J
感觉是一代模拟，没怎么仔细看，估计要使用sscanf了

行吧，这次现场赛的确看出了自己的不足，且行且珍惜把。