第十三届蓝桥杯C++A组 - B/D/E

前言

题目	考点
灭鼠先锋	bfs+博弈论+MEX运算+SG函数
选数异或	二分+线段树
爬树的甲壳虫	快速幂+逆元+扩展欧几里得+裴蜀定理+dp

一、灭鼠先锋

1.题目描述

2.算法

• 我们先要确定什么是必输态，即是只剩一个空格让某人去填时，该人必输
• 我们每次有两种选择，一种是取一个，一种是取连续两个，我们可以进行dfs遍历并实现递归，分别求MEX值
• 但是在这个题我们可以简化不需要求过多的SG值，只需要知道是否可以下一步为0即可，也就是是否下一步有必输态
• SG函数相关内容请查看《数论 - 博弈论（Nim游戏）》

#include<bits/stdc++.h>

using namespace std;

map<string, bool>SG;

///判断是否仅存在一个空格
bool check(string s)
{
    int tot = 0;
    for(auto x : s)if(x == 'O')
        tot++;
    return tot == 1;
}

bool dfs(string s)
{
    //优化,防止多算
    if(SG.count(s)) return SG[s];

    //必输态
    if(check(s))
        return SG[s] = false;

    //模拟放1个棋子
    for(int i = 0; i < s.size(); i++)if(s[i] == 'O')
    {
        string tmp = s;
        tmp[i] = 'X';
        if(dfs(tmp) == false)//可以到达必败态均为必胜态
            return SG[s] = true;
    }

    //模拟放2个棋子
    for(int i = 0; i < s.size() - 1; i++)if(s[i] == 'O' && s[i + 1] == 'O' && i != 3)
    {
        string tmp = s;
        tmp[i] = tmp[i + 1] = 'X';
        if(dfs(tmp) == false)//可以到达必败态均为必胜态
            return SG[s] = true;
    }
    
    ///运行到此，说明只能转移到必胜态，此时为必败态
    return SG[s] = false;
}

int main()
{
    string s[] = {"XOOOOOOO", "XXOOOOOO", "OXOOOOOO", "OXXOOOOO"};
    for(int i = 0; i < 4; i++)
    {
        if(dfs(s[i]))cout<<"L";///此时为必胜态，说明后手面临的局面必胜，输出L
        else cout<<"V";
    }
    return 0;
}

二、选数异或

1.题目描述

2.算法

• 该题需要做的是从选定区间找是否存在两数a、b使得：a异或b = x
• 可知：b = a异或x，那么我们可以找区间内一个值a，再查找该区间是否还存在a异或x，如果存在则可以满足
• 为了方便遍历，我们可以从前往后遍历输入，查找在区间l~f内是否存在这样的a，a的满足数 a异或x 大于l，不需要看是小于r，因为我们是从前往后输入的，所以只有在满足数的位置一定小于a
• 所以只要该区间所有满足数的最大值大于l即可
• 如何找最大值：我们可以通过线段树来查找，反复迭代得到最大值

#include<bits/stdc++.h>

using namespace std;

const int maxn = 100000 + 10;
int tree[maxn << 2]; //线段树
int Left[maxn], pos[(1 << 20) + 10]; //Left[i]，是满足i的上一个的post值
int a[maxn], n, m, x;

//线段树模板,用来反复迭代最大值
void build(int o, int l, int r)
{
	if(l == r)
	{
		tree[o] = Left[l];
		return;
	}
	int mid = (l + r) >> 1;
	build(o << 1, l, mid);
	build(o << 1 | 1, mid + 1, r);
	tree[o] = max(tree[o << 1], tree[o << 1 | 1]);
}

//找区间最大值
int query(int o, int l, int r, int L, int R)
{
	if(L <= l && r <= R)return tree[o];
	int mid = (l + r) >> 1;
	int ans = 0;
	if(L <= mid)ans = max(ans, query(o << 1, l, mid, L, R));
	if(R > mid)ans = max(ans, query(o << 1 | 1, mid + 1, r, L, R));
	return ans;
}

int main()
{
	scanf("%d%d%d", &n, &m, &x);
	for(int i = 1; i <= n; i++) //预处理Left数组
	{
		scanf("%d", &a[i]);
		Left[i] = pos[a[i] ^ x];
		pos[a[i]] = i;
	}
	build(1, 1, n);//线段树建树
	while(m--)
	{
		int l, r;
		scanf("%d%d", &l, &r);
		if(query(1, 1, n, l, r) >= l)//查询区间最值
			printf("yes\n");
		else
			printf("no\n");
	}
	return 0;
}

三、爬树的甲壳虫

1.问题描述

2.算法

• 推导方法：
  
• 由此推导可知：只需要用欧几里得求dp[0]即可
• 由于同余0无法化为有效的dp[0]，则可以改变公式结构：

dp[0] = a * dp[0] + b
(a-1)dp[0]+k * MOD ≡ MOD - b
(a - 1)x + MOD * y ≡ MOD - b

• 这样计算出后，将答案x进行处理：x1 = x * (MOD - b) / g;即可得到答案
• 模板相关内容：《数论 - 欧拉函数、快速幂、扩展欧几里得算法》

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
const int maxn = 1e5 + 10;
const int MOD = 998244353;
ll x[maxn], y[maxn];

//快速幂
ll ksm(ll a, ll b, ll m)
{
	ll ans = 1;
	while(b)
	{
		if(b & 1)ans = ans * a % m;
		b >>= 1;
		a = a * a % m;
	}
	return ans;
}

//求逆元
ll inv(ll x)
{
	return ksm(x, MOD - 2, MOD);
}

//扩展欧几里得求最大公约数
//裴蜀定理：一定存在x,y使得：ax+by = gcd(a, b)。可以将x,y用&分别返回
ll extgcd(ll a, ll b, ll&x, ll&y)
{
	ll d = a;
	if(b)
	{
		d = extgcd(b, a % b, y, x);
		y -= (a / b) * x;
	}
	else x = 1, y = 0;
	return d;
}

int main()
{
	int n;
	cin >> n;

    //输入并且预处理，简化
	for(int i = 1; i <= n; i++)
	{
		cin >> x[i] >> y[i];
		ll g = __gcd(x[i], y[i]); //__gcd是C++自带的求最大公约数函数
		x[i] = x[i] / g;
		y[i] = y[i] / g;
	}

    //算推导公式a,b
	ll a = 0, b = 0;
	for(int i = n; i >= 1; i--)
	{
		ll p = x[i] * inv(y[i]) % MOD, p_1 = (y[i] - x[i]) * inv(y[i]) % MOD;
		a = (p + p_1 * a) % MOD;
		b = (1 + p_1 * b) % MOD;
	}

	//得到x即dp[0]的变种
	ll c = a - 1, d = MOD, x, y;
	ll g = extgcd(c, d, x, y);

	//将dp[0]变化为答案值x1并输出
	ll x1 = x * (MOD - b) / g;
	cout<<(x1 % MOD + MOD ) % MOD<<endl;
	return 0;
}