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]
，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
)
{
check
=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;
}