Codeforces Round #334 (Div. 1)

自从CF的rating改版以后终于回到DIV1了。打了一场还比预期好，如果C题不错的话应该可以继续上分，可惜了。

Codeforces 603A. Alternative Thinking

题目链接：http://codeforces.com/problemset/problem/603/A

题意：给你一个01串，要你选择其中一个非空的01子串，将其反转（0变成1，1变成0），要求结果的01串中找出的最长的01交替的子序列尽可能长。

分析：贪心或者DP都可以。

DP法：

维护数组dp[3][n]，dp[i][j]存储每个状态下到第j位的最长01交替的子序列的长度。

dp[2][i]表示第0位到第i位都没有反转过。

dp[1][i]表示第0位到第i位反转过，并且第i位被反转了

dp[0][i]表示第0位到第i位反转过，并且第i位没有被反转。

状态转移方程见代码。

<span style="font-size:18px;">#include <bits/stdc++.h>
using namespace std;
char s[100005];
int dp[3][100005];
int main()
{
    int n;
    while (~scanf("%d",&n))
    {
        scanf("%s",s);
        memset(dp,0,sizeof(dp));
        dp[2][0]=1;
        dp[1][0]=1;
        dp[0][0]=1;
        for (int i=1;i<n;i++)
        {
            if (s[i]!=s[i-1])
            {
                dp[2][i]=dp[2][i-1]+1;
                dp[1][i]=max(dp[2][i-1],dp[1][i-1]+1);
                dp[0][i]=max(dp[1][i-1],dp[0][i-1]+1);
            }
            else 
            {
                dp[2][i]=dp[2][i-1];
                dp[1][i]=max(dp[2][i-1]+1,dp[1][i-1]);
                dp[0][i]=max(dp[1][i-1]+1,dp[0][i-1]);
            }
        }
        printf("%d\n",max(dp[1][n-1],dp[0][n-1]));
    }
    return 0;
}</span>

贪心法当时没想到，以后有空再补。

Codeforces 603B. Moodular Arithmetic
题目链接：http://codeforces.com/problemset/problem/603/B

题意：

有一个函数映射，其中，现已知K,P，问有多少种不同的满足条件的函数映射。其中p是一个素数并且大于2，0<=k<p

分析：

由于p是素数，所以对任意一个k（不等于0）都能在取模p的情况下形成环。

（注1：一元素在一可交换环R内的方阵是可逆的当且仅当其行列式在R是可逆的。）

对于任意的数x，其逆元存在的情况下，x^p=x，即k^(p-1)=1。故对于任意的x，k^(p-1)*f(f(f(f(.....f(x)))))=x,(函数复合p-1次)。

（注2：实际上数字不一定需要取p-1次幂，只是能保证取p-1次幂一定能得到如上结果。）

在此基础之上，枚举出每个x^t=x的结点t，在每个环中的f(x)数字可以任意取，具体自己在纸上写一下就好了。

另外记得f(0)要单独判断。

#include <bits/stdc++.h>
using namespace std;
const long long mod=1e9+7;
long long k,p;
bool check[1000005];
long long qpow(long long a,long long b)
{
    long long ans=1;
    while (b)
    {
        if (b&1) ans=ans*a%mod;
        a=a*a%mod;
        b>>=1;
    }
    return ans;
}
void DW(long long x)
{
    long long n=x;
    while (!check[n])
    {
        check[n]=1;
        n=k*n%p;
    }
    return ;
}
int main()
{
    long long ans;
    while (cin>>p>>k)
    {
        if (k==0)
        {
            cout<<qpow(p,p-1)<<endl;
            continue;
        }
        memset(check,0,sizeof(check));
        if (k==1) ans=p;
        else ans=1;
        for (int i=1;i<p;i++)
        {
            if (check[i]) continue;
            ans=ans*p%mod;
            DW(i);
        }
        cout<<ans<<endl;
    }
    return 0;
}

Codeforces 603C. Lieges of Legendre

题目链接：http://codeforces.com/problemset/problem/603/C
题意：现有n堆石子和p，每堆石子的个数已知，现在两个人玩游戏，轮流操作。

操作分为两种：

1.从某一堆石子中取走一颗。

2.选取一个石子数量为偶数x的堆，取走整堆，然后重新放入p堆数量为x/2的石子堆。

问先手必胜否。

分析：

上分题，最后少写了一个判断不然就上分了，留个遗憾。

简单博弈，由于对称性可以得出如果仅存在偶数堆两两相对数量相同的石子，那么先手一定必输。

由此可以得出：如果k为奇数，结果和k=1的时候是一样的。如果k为偶数，那么结果和k=0的时候是一样的。

接下来分k=1和k=0讨论.

k=0：操作有两种，从某一堆石子中取走一颗或者对一个偶数堆取走整堆。

k=1：操作有两种，从某一堆石子中取走一颗或者对一个偶数堆取走半堆。

接下来套SG函数即可。

找边界条件的话，可以先把较小范围的数字直接打表打出来，避免特判。

还有就是根据奇偶性判断掉一部分，这个可以根据打表的结果看出来。

但是，但是，但是，重要的事情说三遍，我不是这么写的。。当时不知道怎么抽风了没有想常规套路直接肉眼套规律了。

重点就是打表打表打表，然后看看看，然后就出来了。

嗯开个玩笑。

k=0的情况的话打表能秒看出答案就不说了。

k=1的情况，（直觉很重要，当然证明也不难）对于任意的数字x，如果它是奇数的话，sg值是0，如果是偶数的话，sg值一定是1或者2，这个结果和x/2的结果反一下就好了，（另：如果x/2的值是奇数，那么x的sg值是1）。所以不断的做除法求出一个数字中有多少个2的约数，然后求出结果。注意小数据依旧打表判掉。

#include <bits/stdc++.h>
using namespace std;
int tick(int x)
{
    int num=0;
    while(x%2==0)
    {
        if (x==4) break;
        num++; 
        x/=2;
        if (x==3)
        {
            num++;
            break;
        }
    }
    if (num%2) return 1;
    else return 2;
}
int main()
{
    int n,k,c;
    int sg[21]={0,1,0,1,2,0,2,0,1,0,1,0,1,0,1,0,2,0,1,0,2};
    int sum;
    while (~scanf("%d%d",&n,&k))
    {
        sum=0;
        for (int i=1;i<=n;i++)
        {
            scanf("%d",&c);
            if (k%2==0)
            {
                if (c==1||c==2) sum^=c;
                else sum^=(c-1)%2;
            }
            else 
            {
                if (c<=10) sum^=sg[c];
                else 
                {
                    if (c%2==0) sum^=tick(c);
                }
            }
        }
        if (sum) printf("Kevin\n");
        else printf("Nicky\n");
    }
    return 0;
}