板子

a-c-dream 发布于

杂记

上取整转化为下取整

1
2
3
l/p(上取整) = (l+p-1)/p
3 5==>卡特兰数
除法要用逆元

线性筛

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int primes[N],cnt;
bool st[N];
void get_prime(int n)
{
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
            primes[cnt++] =i;
        for(int j = 0;primes[j]*i<=n;j++)
        {
            st[i*primes[j]] = true;
            if(primes[j]%i==0)
                break;
        }
    }
}

区间筛

  1. 质数距离

给定两个整数 L 和 U，你需要在闭区间 [L,U] 内找到距离最接近的两个相邻质数 C1 和 C2（即 C2−C1 是最小的），如果存在相同距离的其他相邻质数对，则输出第一对。

同时，你还需要找到距离最远的两个相邻质数 D1 和 D2（即 D1−D2 是最大的），如果存在相同距离的其他相邻质数对，则输出第一对。

输入格式
每行输入两个整数 L 和 U，其中 L 和 U 的差值不会超过 1e6。

输出格式
对于每个 L 和 U，输出一个结果，结果占一行。

结果包括距离最近的相邻质数对和距离最远的相邻质数对。（具体格式参照样例）

如果 L 和 U 之间不存在质数对，则输出 There are no adjacent primes.。

数据范围
1≤L<U≤231−1
输入样例：
2 17
14 17
输出样例：
2,3 are closest, 7,11 are most distant.
There are no adjacent primes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include "bits/stdc++.h"

using namespace std;
typedef pair<int, int> PII;
typedef pair<string, int> PSI;
typedef long long ll;
const int N = 1e6 + 3;
int primes[N],cnt,d[N];
bool st[N];
void get_prime(int n)
{
    memset(st,false,sizeof st);
    for(int i = 2;i<=n;i++)
    {

        if(!st[i])
            primes[cnt++] = i;
        for(int j = 0;(ll)primes[j]*i<=n;j++)
        {
            st[(ll)primes[j]*i] = true;
            if(primes[j]%i==0)
                break;
        }
    }

}
int main()
{
    int l,r;
    while (cin>>l>>r)
    {
        get_prime(5e4);
        memset(st,false,sizeof st);
        for(int i = 0;i<cnt;i++)
        {
            ll p = primes[i];
            for(ll j = max(2*p,(l+p-1)/p*p);j<=r;j+=p)
                st[j-l] = true;
        }
        cnt =0;
        for(int i =0;i<=r-l;i++)
            if(!st[i]&&i+l>=2)
                primes[cnt++] = i+l;
        if(cnt<2)
            puts("There are no adjacent primes.");
        else
        {
            int maxp = 0,minp =0;
            for(int i =0 ;i<cnt-1;i++)
            {
                int d = primes[i+1]-primes[i];
                if(d>primes[maxp+1]-primes[maxp])
                    maxp = i;
                if(d<primes[minp+1]-primes[minp])
                    minp = i;
            }
            printf("%d,%d are closest, %d,%d are most distant.\n",primes[minp],primes[minp+1],primes[maxp],primes[maxp+1]);
        }


    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include "bits/stdc++.h"

using namespace std;
typedef pair<int, int> PII;
typedef pair<string, int> PSI;
typedef long long ll;
const int N = 1e6 + 3;
int primes[N],cnt,d[N];
bool st[N];
void get_prime(int n)
{
    memset(st,false,sizeof st);
    for(int i = 2;i<=n;i++)
    {

        if(!st[i])
            primes[cnt++] = i;
        for(int j = 0;(ll)primes[j]*i<=n;j++)
        {
            st[(ll)primes[j]*i] = true;
            if(primes[j]%i==0)
                break;
        }
    }

}
int main()
{
    int l,r;
    while (cin>>l>>r)
    {
        get_prime(5e4);
        memset(st,false,sizeof st);
        for(int i = 0;i<cnt;i++)
        {
            ll p = primes[i];
            for(ll j = max(2*p,(l+p-1)/p*p);j<=r;j+=p)
                st[j-l] = true;
        }
        cnt =0;
        for(int i =0;i<=r-l;i++)
            if(!st[i]&&i+l>=2)
                primes[cnt++] = i+l;
        int res = 0;
        for(ll i = l;i<r;i++)
        {
            if(!st[i-l])
            {
                cout<<i<<endl;
                res++;
            }


        }
        cout<<res<<endl;
    }
    return 0;
}

分解质因数

阶乘分解 197

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
using namespace std;
const int N = 1e6 + 9;
int prime[N], cnt;
bool st[N];
void init(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (!st[i])
            prime[cnt++] = i;
        for (int j = 0; prime[j] * i <= n; j++)
        {
            st[prime[j] * i] = true;
            if (i%prime[j]  == 0)
                break;
        }
    }
}
int main()
{
    int n;
    cin >> n;
    init(n);
    for (int i = 0; i < cnt; i++)
    {
        int s = 0;
        int p = prime[i];
        for (int j = n; j; j /= p)
            s += j / p;
        cout << p << ' ' << s << endl;
    }
    return 0;
}

分解质因数 867

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include<iostream>
#include<algorithm>
using namespace std;
void divide(int x)
{
    for(int i  = 2;i<=x/i;i++)
    {
        if(x%i==0)
        {
            int s = 0;
            while(x%i==0)
                x/=i,s++;
            cout<<i<<' '<<s<<endl;
            
        }
        
    }
    if(x>1)
        cout<<x<<' '<<1<<endl;
    cout<<endl;
}
int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        int x;
        scanf("%d",&x);
        divide(x);

    }
    return 0;
}

快速幂

1
2
3
4
5
6
7
8
9
10
11
12
ll q(int a,int n)
{
    ll res  = 1;
    while(n)
    {
        if(n&1)
            res = ((a%mod)*(res%mod))%mod;
        a = (ll)a*a%mod;
        n>>=1;
    }
    return res;
}

约数个数

给定 n 个正整数 ai，请你输出这些数的乘积的约数个数，答案对 1e9+7 取模。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个整数 ai。

输出格式

输出一个整数，表示所给正整数的乘积的约数个数，答案需对 109+7109+7 取模。

数据范围

1≤n≤100,
1≤ai≤2×1e9

输入样例：

1
2
3
4
3
2
6
8

输出样例：

1
12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <vector>
using namespace std;
const int N = 110, MOD = 1e9 + 7;
#define ll long long
int main()
{
    int n;
    cin >> n;
    unordered_map<int, int> primes;
    while (n--)
    {
        int x;
        cin >> x;
        for (int i = 2; i <= x / i; i++)
        
            while (x % i == 0)
            {
                x /= i;
                primes[i]++;
            }
            if (x > 1)
                primes[x]++;
        
    }
    ll res = 1;
    for (auto p : primes)
        res = res * (p.second + 1) % MOD;
    cout << res << endl;
    return 0;
}

扩展欧几里得

定义：

ax+by=gcd(a,b)=d，在已知a,b的情况下
求解出一组x,y

推导过程：

因为a%b=a-(a/b)b
则有 d=bx1+[a-(a/b)b]y1=bx1+ay1-(a/b)by1=ay1+b(x1-a/by1)
故 x=y1,y=x1-a/by1

性质：

1.若通过扩展欧几里得求出一组特解(x0,y0)，那么有ax0+by0=d.
则方程的通解为，其中k为任意整数
x=x0+k*(b/d)
y=y0-k*(a/d)
2.已知ax+by=d的解，对于ax+by=c的解，c为任意正整数，只有当d|c时才有解
其通解为
x=(c/d)x0+k(b/d)
y=(c/d)y0-k(a/d)

常见用法：

（1）求形如ax+by=c的通解，或从中选取某些特解
（2）求乘法逆元
（3）求解线性同余方程

1
2
3
4
5
6
7
8
9
10
11
ll exgcd(ll a,ll b,ll &x,ll &y)
{
    if(!b)
    {
        x =1,y =0;
        return a;
    }
    ll d = exgcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}

欧拉函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int primes[N],cnt,phi[N];
bool st[N];
void get_phi(int n)
{
    phi[1] = 1;
    for(int i = 2;i<=n;i++)
    {
        if(!st[i])
        {
            primes[cnt++]= i;
            phi[i]= i-1;
            st[i] = true;
        }
        for(int j = 0;primes[j]*i<=n;j++)
        {
            st[i*primes[j]] = true;
            if(i%primes[j]==0)
            {
                phi[i*primes[j]] = phi[i]*primes[j];
                break;
            }
            phi[i*primes[j]]  = phi[i]*(primes[j]-1);

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
int euler(int n){
    int 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;
}

同余方程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include "bits/stdc++.h"

using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int N = 1;
int exgcd(int a,int b,int &x,int &y)
{
    if(!b)
    {
        x = 1;
        y = 0;
        return a;
    }
    int d = exgcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}
int main()
{
    int a,b;
    cin>>a>>b;
    int x,y;
    exgcd(a,b,x,y);
    cout<<(x%b+b)%b<<endl;
    return 0;
}

矩阵乘法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include "bits/stdc++.h"

using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 3;
int a[] = {1,1,2};
ll n,m;
int b[][3] ={{0,1,1},{1,1,1},{0,0,1}};
void mul(int c[N],int a[N],int b[N][N])
{
    int t[N] = {0};
    for(int i =0;i<N;i++)
        for(int j =0;j<N;j++)
                t[i] = t[i]%m+((ll)a[j]%m*b[j][i]%m)%m;
    memcpy(c,t,sizeof t);
}
void mul(int c[N][N],int a[N][N],int b[N][N])
{
    int t[N][N] = {0};
    for(int i = 0;i<N;i++)
        for(int j =0;j<N;j++)
            for(int k =0;k<N;k++)
                t[i][j] = t[i][j]%m+((ll)a[i][k]%m*b[k][j]%m)%m;
    memcpy(c,t,sizeof t);
}
int main()
{
    cin>>n>>m;
    n-=2;
    while(n)
    {
        if(n&1)
            mul(a,a,b);
        mul(b,b,b);
        n>>=1;
    }

    cout<<a[2]%m<<endl;
    return 0;
}

高斯消元解线性方程组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>

using namespace std;

const int N = 110;
const double eps = 1e-8;

int n;
double a[N][N];

int gauss()  // 高斯消元，答案存于a[i][n]中，0 <= i < n
{
    int c, r;
    for (c = 0, r = 0; c < n; c ++ )
    {
        int t = r;
        for (int i = r; i < n; i ++ )  // 找绝对值最大的行
            if (fabs(a[i][c]) > fabs(a[t][c]))
                t = i;

        if (fabs(a[t][c]) < eps) continue;

        for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);  // 将绝对值最大的行换到最顶端
        for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];  // 将当前行的首位变成1
        for (int i = r + 1; i < n; i ++ )  // 用当前行将下面所有的列消成0
            if (fabs(a[i][c]) > eps)
                for (int j = n; j >= c; j -- )
                    a[i][j] -= a[r][j] * a[i][c];

        r ++ ;
    }

    if (r < n)
    {
        for (int i = r; i < n; i ++ )
            if (fabs(a[i][n]) > eps)
                return 2; // 无解
        return 1; // 有无穷多组解
    }

    for (int i = n - 1; i >= 0; i -- )
        for (int j = i + 1; j < n; j ++ )
            a[i][n] -= a[i][j] * a[j][n];

    return 0; // 有唯一解
}


int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n + 1; j ++ )
            scanf("%lf", &a[i][j]);

    int t = gauss();
    if (t == 2) puts("No solution");
    else if (t == 1) puts("Infinite group solutions");
    else
    {
        for (int i = 0; i < n; i ++ )
        {
            if (fabs(a[i][n]) < eps) a[i][n] = 0;  // 去掉输出 -0.00 的情况
            printf("%.2lf\n", a[i][n]);
        }
    }

    return 0;
}

求组合数

给定 n 组询问，每组询问给定两个整数 a，b，请你输出 Cba mod(109+7) 的值。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含一组 a 和 b。

输出格式
共 n 行，每行输出一个询问的解。

数据范围
1≤n≤10000,
1≤b≤a≤2000
输入样例：
3
3 1
5 3
2 2
输出样例：
3
10
1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include "bits/stdc++.h"

typedef long long ll;

using namespace std;
typedef pair<int, int> PII;
const int N = 2e3 + 2, mod = 1e9 + 7;
int c[N][N];

void init()
{
    for (int i = 0; i < N; i++)
        for (int j = 0; j <= i; j++)
            if (j)
                c[i][j] = ((ll)c[i - 1][j] + c[i - 1][j - 1])%mod;
            else
                c[i][j] = 1;

}


int main()
{
    init();
    int n;
    cin >> n;
    int a, b;
    while (n--)
    {
        cin >> a >> b;
        cout << c[a][b]%mod << endl;

    }
    return 0;
}

给定 n 组询问，每组询问给定两个整数 a，b，请你输出 Cbamod(1e9+7) 的值。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含一组 a 和 b。

输出格式
共 n 行，每行输出一个询问的解。

数据范围
1≤n≤10000,
1≤b≤a≤1e5
输入样例：
3
3 1
5 3
2 2
输出样例：
3
10
1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include "bits/stdc++.h"

typedef long long ll;

using namespace std;
typedef pair<int, int> PII;
const int N = 1e5 + 2, mod = 1e9 + 7;
int fact[N], infact[N];

int qmi(int a,int n)
{
    int res =1;
    while(n)
    {
        if(n&1)
            res = (ll)res*a%mod;
        a = (ll)a*a%mod;
        n>>=1;
    }
    return res;
}
int main()
{
    int n;
    int a, b;
    fact[0] = infact[0] = 1;

    for (int i = 1; i < N; i++)
    {
        fact[i]= (ll)fact[i-1]*i%mod;
        infact[i] = (ll)qmi(fact[i],mod-2);
    }
    scanf("%d", &n);

    while (n--)
    {
        scanf("%d%d", &a, &b);
        printf("%d\n",(ll)fact[a]*infact[b]%mod*infact[a-b]%mod);
    }
    return 0;
}

给定 n 组询问，每组询问给定三个整数 a,b,p，其中 p 是质数，请你输出 Cbamodp 的值。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含一组 a,b,p。

输出格式
共 n 行，每行输出一个询问的解。

数据范围
1≤n≤20,
1≤b≤a≤1e18,
1≤p≤1e5,

输入样例：
3
5 3 7
3 1 5
6 4 13
输出样例：
3
3
2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include "bits/stdc++.h"

typedef long long ll;

using namespace std;
typedef pair<int, int> PII;
const int N = 1e5 + 2;
#define int ll
ll a,b,p;
int qmi(int a,int n)
{
    int res = 1;
    while(n)
    {
        if(n&1)
            res =(ll)res*a%p;
        a = (ll)a*a%p;
        n>>=1;
    }
    return res;

}
int C(int n,int m)
{
    if(m>n)
        return 0;
    int res =1;
    for(int i = n,j = m;j>0;j--,i--)
    {
        res = (ll)res*i%p;
        res = (ll)res*qmi(j,p-2);
    }
    return res;
}
int lucas(ll a,ll b)
{
    if(a<p&&b<p)
        return C(a,b);
    return (ll)C(a%p,b%p)* lucas(a/p,b/p)%p;
}
signed main()
{
    int n;
    cin>>n;
    while(n--)
    {
        cin>>a>>b>>p;
        cout<<lucas(a,b)%p<<endl;
    }
    return 0;
}

输入 a,b，求 Cba 的值。

注意结果可能很大，需要使用高精度计算。

输入格式
共一行，包含两个整数 a 和 b。

输出格式
共一行，输出 Cba 的值。

数据范围
1≤b≤a≤5000
输入样例：
5 3
输出样例：
10

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include "bits/stdc++.h"

typedef long long ll;

using namespace std;
typedef pair<int, int> PII;
const int N = 5e3 + 3;
int primes[N], sum[N], cnt;
bool st[N];

void get_prime(int n)
{
    for (int i = 2; i <= n; i++)
    {
        if (!st[i])
            primes[cnt++] = i;
        for (int j = 0; primes[j] * i <= n; j++)
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0)
                break;
        }
    }
}

int get(int n, int p)
{
    int res = 0;
    while (n)
    {
        res += n / p;
        n /= p;
    }
    return res;
}

vector<int> mul(vector<int> a, int b)
{
    vector<int> res;
    int len = a.size();
    int t = 0;
    
    for (int i = 0; i < len; i++)
    {
        t += a[i] * b;
        res.push_back(t % 10);
        t /= 10;
    }
    while (t)
    {
        res.push_back(t % 10);
        t /= 10;
    }
    return res;
}

int main()
{
    int n, m;
    cin >> n >> m;
    get_prime(n);
    for (int i = 0; i < cnt; i++)
    {
        int p = primes[i];
        sum[i] = get(n, p) - get(n - m, p) - get(m, p);
    }
    vector<int> res;
    res.push_back(1);
    for (int i = 0; i < cnt; i++)
        for (int j = 0; j < sum[i]; j++)
            res = mul(res, primes[i]);
    for (int i = res.size() - 1; i >= 0; i--)
        cout << res[i];
    cout << endl;
    return 0;
}

卡特兰数

3 5

image-20220519121116433

C(2n,n)/(n+1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include "bits/stdc++.h"

typedef long long ll;

using namespace std;
typedef pair<int, int> PII;
const int N= 1,mod = 1e9+7;
int qmi(int a,int n)
{
    int res = 1;
    while(n)
    {   
        if(n&1)
            res = (ll)res*a%mod;
        a = (ll)a*a%mod;
        n>>=1;
    }
    return res;
}
int main()
{
    int n;
    cin>>n;
    int a = n<<1,b = n;
    int res = 1;
    for(int i =a;i>a-b;i--)
        res = (ll)res*i%mod;
    for(int i = b;i>=1;i--)
        res = (ll)res*qmi(i,mod-2)%mod;
    
    res =(ll)res*qmi(n+1,mod-2)%mod;
    cout<<res%mod<<endl;
    return 0;
}

nim游戏

尼姆游戏(Nim Game)是由n对石子，数量分别是{a1,a2,…,an}，两个玩家轮流拿石子，每次可以从任意一堆拿走任意数量的石子，拿到最后一个石子的玩家获胜。
结论是若a1⊕a2⊕…an≠0，则先手必胜（N），否则先手必败（P）

分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;


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

    int res = 0;
    while (n -- )
    {
        int x;
        scanf("%d", &x);
        res ^= x;
    }

    if (res) puts("Yes");
    else puts("No");

    return 0;
}

sg函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include<iostream>
#include<cstring>
#include<algorithm>
#include<set>

using namespace std;

const int N=110,M=10010;
int n,m;
int f[M],s[N];//s存储的是可供选择的集合,f存储的是所有可能出现过的情况的sg值

int sg(int x)
{
    if(f[x]!=-1) return f[x];
    //因为取石子数目的集合是已经确定了的,所以每个数的sg值也都是确定的,如果存储过了,直接返回即可
    set<int> S;
    //set代表的是有序集合(注:因为在函数内部定义,所以下一次递归中的S不与本次相同)
    for(int i=0;i<m;i++)
    {
        int sum=s[i];
        if(x>=sum) S.insert(sg(x-sum));
        //先延伸到终点的sg值后,再从后往前排查出所有数的sg值
    }

    for(int i=0;;i++)
    //循环完之后可以进行选出最小的没有出现的自然数的操作
     if(!S.count(i))
      return f[x]=i;
}

int main()
{
    cin>>m;
    for(int i=0;i<m;i++)
    cin>>s[i];

    cin>>n;
    memset(f,-1,sizeof(f));//初始化f均为-1,方便在sg函数中查看x是否被记录过

    int res=0;
    for(int i=0;i<n;i++)
    {
        int x;
        cin>>x;
        res^=sg(x);
        //观察异或值的变化,基本原理与Nim游戏相同
    }

    if(res) printf("Yes");
    else printf("No");

    return 0;
}

巴什游戏

巴什游戏(Bash Game)是n颗石子，每次可以拿1~m颗，两人轮流。
结论是若n%( m + 1 ) = = 0 则先手败，否则先手胜。

a-c-dream

a-c-dream

贵在坚持

93
13
0
CATEGORYS
TAGS