A - A^B Mod C
题目描述：
给出3个正整数A B C，求A^B Mod C。
例如，3 5 8，3^5 Mod 8 = 3。
输入格式
3个正整数A B C，中间用空格分隔。(1 <= A,B,C <= 10^9)
输出格式
输出计算结果
Sample Input
3 5 8
Sample Output
3
思路
数据范围太大了，次方之后绝对会炸数据范围
所以使用快速幂
可参考快速幂
以p=2，n=8为例
常规是通过连乘法求幂，即2^8=2 * 2 * 2 * 2 * 2 * 2 * 2 * 2
这样做的要做8次乘法
而反复平方法则不同，
定义幂sq=1，再检查n是否大于0，
While，循环过程若发现n为奇数，则把此时的p值乘到sq
{
n=8>0 ，把p自乘一次， p=pp=4 ，n取半 n=4
n=4>0 ，再把p自乘一次， p=pp=16 ，n取半 n=2
n=2>0 ，再把p自乘一次， p=pp=256 ，n取半 n=1，sq=sqp
n=1>0 ，再把p自乘一次， p=p*p=256^2 ，n取半 n=0，弹出循环
}
则sq=256就是所求，显然反复平方法只做了3次乘法
核心代码
ull ksm(ull a, ull b, ull mod) {
ull ans = 1, base = a;
while(b != 0) {
if (b & 1 != 0) {
ans = (ans * base) % mod;
}
base = (base * base) % mod;
b >>= 1;
}
return ans;
}
b >>= 1 是把 b 的二进制形式向右移1位，等价于除以二，但是比 b /= 2； 要快速一点
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
typedef unsigned long long ull;
typedef long long ll;
ull ksm(ull a, ull b, ull mod) {
ull ans = 1, base = a;
while(b != 0) {
if (b & 1 != 0) {
ans = (ans * base) % mod;
}
base = (base * base) % mod;
b >>= 1;
}
return ans;
}
int main() {
ull a, b, c;
scanf("%llu%llu%llu", &a, &b, &c);
printf("%llu", ksm(a, b, c));
return 0;
}
B - 逆元
题目描述：
阿克克希是求婚总动员的队长，他通过自己的双手，成就了无数年轻人的梦，但他却留下了悲伤的泪水。
求婚是非常费力的，他手上有 P−1 个求婚请求，这 i个人的编号为 [1,P−1]
面对第 i个人他的求婚麻烦值为：i在模 PPP 意义下的逆元。
他现在想知道总的麻烦值。
tips: 如果有任意一个编号 i 在模 i 意义下不存在逆元，请输出 AKCniubi
输入格式
一行一个数 PPP 表示求婚请求总数
输出格式
一行一个数表示总麻烦值
若有数存在无逆元的情况，输出 AKCniubi
数据范围
对于 30% 的数据，P<=1000000
对于 50% 的数据，P<=10000000
对于 100%的数据，P<=2^31
Sample Input
3
Sample Output
3
思路
由逆元性质可以知道，当 i 和 p 互质时，才有逆元，
若 p 是质数， 而 i 小于p，不可能是p的倍数，所以互质
并且，前几个质数的逆元和是 1 加到 p - 1 的和，用等差数列求
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#define MS(a, b) memset(a, b, sizeof(a))
typedef unsigned long long ull;
typedef long long ll;
int prime(ll t) {
ll a = sqrt(t);
for (int i = 2; i <= a; i++) {
if (t % i == 0)return 0;
}
return 1;
}
int main() {
ll p, sum = 0;
scanf("%lld", & p);
if (!prime(p)) printf("AKCniubi");
else {
printf("%lld", (p-2 + 1)*p/2);
}
return 0;
}
C - 判决素数个数
题目描述：
输入两个整数X和Y，输出两者->>之间<<-的素数个数（包括X和Y）。
输入格式
两个整数X和Y（1 <= X,Y <= 10^5）。
输出格式
输出一个整数，表示X，Y之间的素数个数（包括X和Y）。
Sample Input
1 100
Sample Output
25
思路
很简单的题，数据范围也很小，可以直接判断是否是素数，暴力循环遍历计数，但是有一个大坑，并没有说x，y谁更大，会很容易下意识地认为x<y，这样就错误了
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
int prime(int t) {
if (t == 1 || t == 0) return 0;
else if (t == 2) return 1;
else if (t % 2 == 0) return 0;
else {
int a = sqrt(t);
for (int i = 2; i <= a; i++)
if (t % i == 0) return 0;
}
return 1;
}
int main() {
int x, y;
scanf("%d %d", &x, &y);
int cnt = 0;
int t;
//超级大坑，并没有说 X , Y 谁更大
if (y < x) t = x, x = y, y = t;
for (int i = x; i <= y; i++) {
cnt += prime(i);
}
printf("%d\n", cnt);
return 0;
}
D - 矩阵乘法
题目描述：
计算两个矩阵的乘法。n×m 阶的矩阵 A 乘以 m×k 阶的矩阵 B 得到的矩阵 C 是 n×k阶的，
且 C[i][j] = A[i][0]×B[0][j]+A[i][1]×B[1][j]+……+A[i][m−1]×B[m−1][j]
C[i][j] 表示 C矩阵中第 i 行第 j 列元素)。
输入格式
第一行为 n,m,k表示 A矩阵是 n 行 m 列，B 矩阵是 m行 k列，n,m,k均小于 100；
然后先后输入 A 和 B 两个矩阵，A 矩阵 n 行 m 列，B 矩阵 m 行 k 列，矩阵中每个元素的绝对值不会大于 1000。
输出格式
输出矩阵C，一共 n行，每行 k 个整数，整数之间以一个空格分开。
Sample Input
3 2 3
1 1
1 1
1 1
1 1 1
1 1 1
Sample Output
2 2 2
2 2 2
2 2 2
思路
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
typedef unsigned long long ull;
typedef long long ll;
int main() {
int a[101][101], b[101][101],c[101][101], n, m, k, sum = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &a[i][j]);
for (int i = 0; i < m; i++)
for (int j = 0; j < k; j++)
scanf("%d", &b[i][j]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
for (int p = 0; p < m; p++)
sum += a[i][p] * b[p][j];
c[i][j] = sum;
sum = 0;
}
}
for (int i = 0; i < n; i++){
for (int j = 0; j < k; j++) {
if (j == 0) printf("%d", c[i][j]);
else printf(" %d", c[i][j]);
}
printf("\n");
}
return 0;
}
E - Bash游戏
题目描述：
有一堆石子共有N个。A B两个人轮流拿，A先拿。每次最少拿1颗，最多拿K颗，拿到最后1颗石子的人获胜。假设A B都非常聪明，拿石子的过程中不会出现失误。给出N和K，问最后谁能赢得比赛。
例如N = 3，K = 2。无论A如何拿，B都可以拿到最后1颗石子。
输入格式
第1行：一个数T，表示后面用作输入测试的数的数量。（1 <= T <= 10000) 第2 - T + 1行：每行2个数N，K。中间用空格分隔。（1 <= N,K <= 10^9)
输出格式
共T行，如果A获胜输出A，如果B获胜输出B。
Sample Input
4
3 2
4 2
7 3
8 3
Sample Output
B
A
A
B
思路
经典博弈论的取石子（NIM）游戏
巴氏博弈
详见博弈论之取石子游戏的学习
奇异局势是 n%(m+1) == 0
谁面对这个局势谁输，直接判断即可，若满足，先手输
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n, k, t;
scanf("%d", &t);
while(t--) {
scanf("%d%d", &n, &k) ;
if (k >= n) printf("A\n");
else if (n % (k+1) == 0) printf("B\n");
else printf("A\n");
}
return 0;
}
F - 取石子游戏
题目描述：
有两堆石子，数量任意，可以不同。游戏开始由两个人轮流取石子。游戏规定，每次有两种不同的取法，一是可以在任意的一堆中取走任意多的石子；二是可以在两堆中同时取走相同数量的石子。最后把石子全部取完者为胜者。现在给出初始的两堆石子的数目，如果轮到你先取，假设双方都采取最好的策略，问最后你是胜者还是败者。
输入格式
输入包含若干行，表示若干种石子的初始情况，其中每一行包含两个非负整数a和b，表示两堆石子的数目，a和b都不大于1,000,000,000。
输出格式
输出对应也有若干行，每行包含一个数字1或0，如果最后你是胜者，则为1，反之，则为0。
Sample Input
2 1
8 4
4 7
Sample Output
0
1
0
思路
威佐夫博弈
详见博弈论之取石子游戏的学习
假设，a < b
p = (1 + sqrt(5.0)) / 2; p = 1.618
也就是黄金分割数加一
奇异局势是 (int)( (b-a) * p) == a
直接判断即可，满足上式，则先手输
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
typedef unsigned long long ull;
typedef long long ll;
int main() {
int a, b, t, temp;
double p;
while(scanf("%d%d", &a, &b) != EOF) {
if (b < a) t = a, a = b, b = t;
p = (1 + sqrt(5.0) )/ 2;
t = b - a;
temp = (int)(t * p);
if (a == temp) printf("0\n");
else printf("1\n");
}
return 0;
}
G - Matches Game
题目描述：
这是一个简单的游戏。在这个游戏中，有几堆火柴和两名玩家。这两个玩家轮流进行。在每一轮中，玩家可以选择一堆并从堆中取出任意数量的火柴（当然，取出的火柴数量不能为零，也不能大于所选堆中的火柴数量）。如果一名玩家取完火柴后，没有剩下火柴，该玩家就是赢家。假设这两个玩家都会作出最优决策。你的工作是判断先手玩家能否赢得比赛。
输入格式
输入由几行组成，每行中都有一个测试用例。 在一行的开头，有一个整数M（1<=M<=20），它是火柴堆的数量。然后是M个不大于10000000的正整数。这些M个整数表示每堆中的火柴数。
输出格式
对于每个测试用例，如果第一个玩家获胜，在一行中输出“Yes”，否则输出“No”。
Sample Input
2 45 45
3 3 6 9
Sample Output
No
Yes
思路
尼姆博弈
详见博弈论之取石子游戏的学习
奇异局势就是 所有堆的火柴数的异或和 = 0
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
typedef unsigned long long ull;
typedef long long ll;
int main() {
int m;
while (scanf("%d", &m) != EOF) {
ll a, t = 0;
while(m--) {
scanf("%lld", &a);
t ^= a;
}
// 看错最终结果了，No o是小写
if (!t) printf("No\n");
else printf("Yes\n");
}
return 0;
}
H - 互质数的个数（一）
题目描述：
这里我们定义 φ(n) 表示所有小于等于 nnn 与 nnn 互质数的个数。
例如 φ(10)=4，因为我们可以在 1∼10 中找到 1,3,7,9 与 10互质。
输入格式
第一行输入一个整数 t，表示测试数据组数。
接下来 t行，每行有一个整数 n。
输出格式
对于每组测试数据输出 φ(n)
数据范围
1≤t≤100,1≤n≤10^10。
Sample Input
3
2
10
100
Sample Output
1
4
40
思路
数据范围很大，直接暴力先循环1~n，再判断是否互质，会炸数据范围
因此，采用更方便的 欧拉函数
欧拉函数是小于x的整数中与x互质的数的个数，一般用φ(x)表示。特殊的，φ(1)=1。
埃拉托斯特尼筛求欧拉函数
ull eular(ull n)
{
ull ans = n;
for(int i=2; i*i <= n; ++i)
{
if(n%i == 0)
{
ans = ans/i*(i-1);
while(n%i == 0)
n/=i;
}
}
if(n > 1) ans = ans/n*(n-1);
return ans;
}
代码实现
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
typedef unsigned long long ull;
typedef long long ll;
ull eular(ull n)
{
ull ans = n;
for(int i=2; i*i <= n; ++i)
{
if(n%i == 0)
{
ans = ans/i*(i-1);
while(n%i == 0)
n/=i;
}
}
if(n > 1) ans = ans/n*(n-1);
return ans;
}
int main() {
int t;
ull a;
scanf("%d", &t) ;
while (t--) {
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
scanf("%llu", &a);
printf("%llu\n",eular(a));
}
return 0;
}
I - Sumdiv
题目描述
有两个自然数a和b(a,b≤50000000)
求a的b次方的所有约数之和模9901
输入格式
一行，包含由空格分隔的两个自然数a和b
输出格式
一行，a的b次方的约数和模9901
Sample Input
2 3
Sample Output
15
样例解释
8的约数是1,2,4,8， 它们的总和是15
\15模9901是15
思路
约数和公式 + 快速幂
详见数论
代码
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#define MS(a, b) memset(a, b, sizeof(a))
typedef unsigned long long ull;
typedef long long ll;
#define MAX 1000000
#define MOD 9901
ll f[MAX], t[MAX];
ll qp(ll a, ll b) {//快速幂
ll base = a;
ll ans = 1;
while(b) {
if (b & 1) {
ans =(ans * base) % MOD;
}
base =(base * base) % MOD;
b >>= 1;
}
return ans;
}
ll sum(ll a, ll b) {//约数和公式
if (b == 0) return 1;
if (b % 2 ) return sum(a, b/2) * (1 + qp(a, b/2 + 1)) % MOD;
else return ((sum(a, b/2 - 1) * (1 + qp(a, b/2 + 1)))%MOD + qp(a, b/2)) ;
}
int main() {
ll a, b;
ll ans = 1;
scanf("%lld%lld", &a, &b);
ll k = 0;
for (int i = 2; i*i <= a; ) {
int flag = 0;
while (a % i == 0) {
flag = 1;
f[k] = i;
t[k]++;
a /= i;
}
if (flag) k++;
if (i == 2)i++;
else i += 2;
}
if (a != 1) {
f[k] = a;
t[k++]++;//为了下面的循环，变量可以正常使用
}
for (int i = 0; i < k; i++) {
ans =( ans % MOD * sum(f[i], t[i]*b) % MOD) % MOD;
}
printf("%lld", ans);
return 0;
}
J - The Lottery
题目描述
给出n , m，和m个数a[1]⋯a[m]。
求1⋯n中不被a[1]⋯a[m]中任意一个整除的数的个数。
10⩽n<2^31 ,1⩽m⩽15
输入格式
每组数据以n,m为第一行。
第二行m个数，表示a[i]。
输入文件以EOF结尾。
输出格式
每组数据一行一个数字表示答案。
Sample Input
10 2
2 3
20 2
2 4
Sample Output
3
10
思路
二进制枚举+gcd+lcm+容斥
容斥，奇加偶减
详见容斥1
容斥简介
容斥模板
二进制枚举
代码
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#define MS(a, b) memset(a, b, sizeof(a))
typedef unsigned long long ull;
typedef long long ll;
ll a[16];
ll gcd(ll a, ll b) {
// if(b == 0)return a;
return b==0?a:gcd(b, a%b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
int main() {
ll n, m;
while(~scanf("%lld%lld", &n, &m)) {
MS(a, 0);
for(int i = 0; i < m; i++)
scanf("%lld", &a[i]);
ll ans = 0, sum = 0;
for (int i = 1; i < (1 << m); i++) {
ll cnt = 0, ans = 1;
for (int j = 0; j < m; j++) {
if (i & (1 << j)) {
ans = lcm(ans, a[j]);
if (ans > n) break;
cnt ++;
}
}
if (cnt & 1)
sum += n/ans;
else sum -= n/ans;
}
printf("%lld\n", n - sum);
}
}
K - 组合数问题
题目描述
输入格式
第一行有两个整数 t,k，其中 ttt 代表该测试点总共有多少组测试数据，k 的意义见题目描述。
接下来 t 行，每行两个整数 n,m，其中 n,m 的意义见题目描述。
输出格式
t 行，每行一个整数代表所有的 0≤i≤n,0≤j≤min(i,m)中有多少对 (i,j)满足 C(i,j) 是 k 的倍数。
数据范围
Sample Input
1 2
3 3
Sample Output
1
Sample Input
2 5
4 5
6 7
Sample Output
0
7
思路
排列组合有公式
C(i,j) = C(i-1 , j) + C(i-1 , j-1)
所以直接二维数组杨辉三角
直接加和就好
然后发现TLE了，再利用前缀和，接着预处理缩短时间
代码
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#define MS(a, b) memset(a, b, sizeof(a))
typedef unsigned long long ull;
typedef long long ll;
// 数据较少，可以直接提前使用 数组，来预处理一下
// 其实组合数就是杨辉三角，直接推出来杨辉三角的值，直接使用即可
// C(i,j) = C(i-1, j) + C(i-1, j-1) ;
// 之后发现，从i = 0; i < n ; i++
// j = 0 ; j <= i ; j++
//开始循环，还是会TLE ,所以，进一步处理，直接算前缀和，载加上每一列最后的前缀和；
int a[2010][2010], n, m, k, t, vis[2010][2010];
ll min(ll a, ll b) {
if (a < b)return a;
return b;
}
void yhsj(int c[][2010]) {
for (int i = 0; i < 2000; i++) {
c[i][0] = 1;
c[i][i] = 1;
}
for (int i = 1; i < 2000; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i-1][j]+ c[i-1][j-1]) % k;
if (c[i][j] == 0) vis[i][j] = 1;
}
}
for (int i = 0; i < 2000; i++) {
// vis[i][0] += vis[i-1][i-1] ;
for (int j = 0; j <= i; j++) {
// 把每一列的，加成前缀和
vis[i][j] += vis[i][j-1];
}
}
}
int main () {
scanf("%d%d", &t, &k);
yhsj(a);
while(t--) {
int ans = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) {
//行数是确定的，直接从 1 - > n ，但是列的坐标要取 i 和 m 中小的那一个，
//所以按列来加和前缀和 ，直接加和 列指向的那个坐标中的前缀和即可
ans += vis[i][min(i, m)];
}
printf("%d\n", ans);
}
}
L - 同余方程
题目描述
求关于 x 的同余方程 ax≡1( mod b) 的最小正整数解。
输入格式
输入只有一行，包含两个正整数 a,b，用一个空格隔开。
输出格式
输出只有一行，包含一个正整数 x0，即最小正整数解。输入数据保证一定有解。
数据范围
对于 40% 的数据，2≤b≤1,000；
对于 60% 的数据，2≤b≤50,000,000；
对于 100% 的数据，2≤a,b≤2,000,000,000。
Sample Input
3 10
Sample Output
7
思路
扩展欧几里得算法
详见扩展欧几里得算法（详细推导+代码实现+应用）
扩展欧几里得算法详解
扩展欧几里得算法详解2
代码
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#define MS(a, b) memset(a, b, sizeof(a))
typedef unsigned long long ull;
typedef long long ll;
ll gcdEx(ll a, ll b, ll & x, ll & y)
{
if(b==0)
{
x=1,y=0 ;
return a ;
}
else
{
ll r=gcdEx(b,a%b,x,y);
/* r = GCD(a, b) = GCD(b, a%b) */
ll t=x ;
x=y ;
y=t-a/b*y ;
return r ;
}
}
ll inv(ll a,ll m)
{
ll x,y;
if(gcdEx(a,m,x,y)!=1)
return -1;//不互质 不存在逆元
return (x%m+m)%m;
}
int main() {
ll a, b;
ll x ;
scanf("%d%d", &a, &b);
x = inv(a, b);
if(x != -1)
printf("%lld", x);
return 0;
}
877
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
