蓝桥杯 on 安洛的小窝

[蓝桥杯2024国A]gcd与lcm

Sun, 02 Feb 2025 22:39:12 +0800

封面图：https://www.pixiv.net/artworks/126731977

题目描述

给定两个数 $x,y$，求有多少种不同的长度为 $n$ 的序列 $(a_1,a_2,\cdots,a_n)$，其所有元素的最大公约数为 $x$ 且最小公倍数为 $y$。

两个序列 $(a_1,a_2,\cdots,a_n)$ 与 $(b_1,b_2,\cdots,b_n)$ 不同，是指存在至少一个位置 $i$ 满足 $a_i\neq b_i$。

由于答案可能很大，请输出答案对 $998\ 244\ 353$ 取模后的结果。

输入格式

输入的第一行包含一个整数 $Q$ 表示询问次数。

接下来 $Q$ 行，每行包含三个整数 $x,y,n$ 表示一组询问，相邻整数之间使用一个空格分隔。对于每个询问，保证至少存在一个满足条件的序列。

输出格式

输出 $Q$ 行，每行包含一个整数，依次表示每个询问的答案。

输入输出样例 #1

输入 #1

3
3 6 2
12 144 3
233 251640 10

输出 #1

1
2
3

2
72
905954656

说明/提示

对于 $40%$ 的评测用例，$n\le 30$；
对于 $70%$ 的评测用例，$n\le 5000$；
对于所有评测用例，$1\le Q\le 100$，$2\le n\le 10^5$，$1\le x,y\le 10^9$。

解题思路

在蓝桥杯做的第二道排列组合，非常简单，然而没能做出来 QAQ。

这道题题目里虽然有 gcd 和 lcm，但是其实并不需要求 gcd 或 lcm。由题目条件可以想到，$y=0\mod x$。令 $t=y\div x$，那么 $t=0\mod a_i$。若对 $t$ 分解质因数得到 $t=p_1^{k_1}p_2^{k_2}p_3^{k_3}\cdots$，那么 $a_i$ 实际上就是这些质因数的排列组合。考虑质因数 $p_i$，它在每个 $a$ 中的次数都可能为 $[0,k_i]$，共 $k_i+1$ 种可能。那么考虑所有 $a_i$，根据乘法原理，就有 $(k_i+1)^n$ 种可能。但是，有两种情况是不允许的：所有 $a_i$ 中 $p_i$ 的次数都不为 $0$，这样的话它们的最大公因数就是 $x\cdot p_i^{j_i}$，$j_i$ 为所有 $a_i$ 中 $p_i$ 最低的次数；同理，如果所有 $a_i$ 中 $p_i$ 的次数都不为 $k_i$，则会导致最小公倍数小于 $y$。因此我们需要减去这两种情况。第一种情况时，$p_i$ 的次数可能为 $[1,k_i]$，共 $k_i$ 种可能。第二种情况时，$p_i$ 的次数可能为 $[0,k_i-1]$，也是 $k_i$ 种可能。考虑所有 $a_i$ 就是 $k_i^n$ 种可能。因此我们要减去 $2k_i^n$。这时候注意到次数为 $[1,k_i-1]$ 的情况被减去了两次，因此再加上 $2(k_i-1)^n$。单个 $p_i$ 的次数的所有可能数就为 $(k_i+1)^n-2k_i^n+(k_i-1)^n$。所有 $p_i$ 之间实际上互不影响，因此最终总可能数就是 $\sum_{i=1}^n(k_i+1)^n-2k_i^n+(k_i-1)^n$。

因为需要求模，实现的时候需要手写快速幂。

代码

附上 AC 代码。

#include<iostream>
#include<utility>
#include<vector>
#include<cmath>
using namespace std;
using ll=long long;
using pf=pair<int,int>;
const auto M=998244353;
const ll MAXX=1e9;
int q;

bool isprime(ll a)
{
    if (a==0||a==1) return false;
    if (a==2) return true;
    for (ll i=2;i*i<=a;i++)
    {
        if (a%i==0) return false;
    }
    return true;
}
vector<pf> fac(int t)
{
    vector<pf> result;
    for (auto i=2;i<=t;i++)
    {
        if (t%i==0&&isprime(i))
        {
            int p=0;
            while (t%i==0)
            {
                t/=i;
                p++;
            }
            result.emplace_back(t,p);
        }
    }
    return result;
}
ll qpow(ll a,ll p)
{
   ll t=1,ans=1,at=a;
   while(t<=p)
   {
       if (p&t) ans=ans*at%M;
       t<<=1;
       at=at*at%M;
   }
   return ans;
}

int main()
{
    cin>>q;
    for (auto i=0; i<q; i++)
    {
        int x,y;
        int n;
        cin>>x>>y>>n;
        auto t=y/x;
        vector<pf> tpf=fac(t);
        ll ans=1;
        for (auto j:tpf)
        {
            ll tmp=qpow(1+j.second,n);
            tmp=(tmp-qpow(j.second,n));
            tmp=(tmp-qpow(j.second,n));
            tmp=(tmp+qpow(j.second-1,n))%M;
            tmp=(tmp+M)%M;
            ans*=tmp;
            ans%=M;
        }
        cout<<ans<<endl;
    }
}

[蓝桥杯2024国A]最长子段题解

Mon, 27 Jan 2025 16:58:57 +0800

封面图源见水印。

题目描述

给定一个长度为 $n$ 的序列 $(s_1,s_2,\cdots,s_n)$ 和三个数 $a,b,c$，你需要找出一对 $L,R$ 满足如下式子：

$$ \sum\limits_{i=L}^Rs_i>a(bR-cL),1 \le L \le R \le n $$

即，序列中的第 $L$ 至 $R$ 项之和大于 $a\cdot (b\cdot R - c \cdot L)$，求出满足条件的 $L,R$ 中 $R - L + 1$ 的最大值。

测试数据保证存在这样的一对 $L$ 和 $R$。

输入格式

输入的第一行包含四个整数 $n,a,b,c$，相邻整数之间使用一个空格分隔。

第二行包含 $n$ 个整数 $s_1,s_2,\cdots,s_n$，相邻整数之间使用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。

样例 #1

样例输入 #1

1
2

4 1 5 6
1 2 3 4

样例输出 #1

提示

对于 $60%$ 的评测用例，$n\le 5000$；
对于所有评测用例，$1\le n\le 3 \times 10^5$，$1\le a,b,c\le 1000$，$|s_i| \le 10^9$。

解题思路

这道题第一眼看到算法标签有二分，马上联想到二分区间长度，然后枚举区间位置来检查答案。于是光速写下如下代码：

#include <algorithm>
#include <array>
#include <iostream>
using namespace std;
using ll = long long;
const int MAXN = 3e5;
int n;
ll a, b, c;
array<ll, MAXN + 5> s;
array<ll, MAXN + 5> sum;

bool check(int mid)
{
    for (auto i = 1; i + mid - 1 <= n; i++)
    {
        ll l = i, r = i + mid - 1;
        if (sum.at(r) - sum.at(l - 1) > a * (b * r - c * l))
            return true;
    }
    return false;
}

int main()
{
    cin >> n >> a >> b >> c;
    for (auto i = 1; i <= n; i++)
    {
        cin >> s.at(i);
        sum.at(i) = s.at(i) + sum.at(i - 1);
    }
    auto l = 1, r = n, ans = 0;
    while (l <= r)
    {
        auto mid = (l + r) / 2;
        if (check(mid))
        {
            ans = mid;
            l = mid + 1;
        }
        else
        {
            r = mid - 1;
        }
    }
    cout << ans;
    return 0;
}

喜提 WA。一开始我还以为是数据范围之类的问题，检查半天，然后猛然发现并非如此。这里要注意二分的一个重要条件，即保证答案是单调的。在上面的代码中，如果一个区间长度被判定为不符合，那么程序就不会搜索比它更长的区间了。但这是不对的。在本题中，一个短区间不符合条件，并不代表长区间也不符合条件。因此，如果希望使用二分搜索，就必须使搜索的目标满足单调条件。那么有没有这样的目标呢？有的有的，这样的目标还有两个，那就是区间的左端点或右端点。但当然不能直接搜索，需要先做一些处理。

我们思考题目给出的条件：$\sum\limits_{i=L}^Rs_i>a(bR-cL),1 \le L \le R \le n$。首先很容易想到用前缀和处理左边的 $\sum\limits_{i=L}^Rs_i$。于是等式左边可以分解为 $sum[r]-sum[l-1]$。这个式子可以移项，将带有 $r$ 的部分和带有 $l$ 的部分分置不等式两边，即 $sum[r]-abr>sum[l-1]-acl$。这暗示我们可以将两个端点分开处理。我们不妨先假设 $r$ 是固定的，思考 $l$ 的情况。根据不等式，$sum[l-1]-acl$ 越小越好，同时根据题目要求区间长度尽量大，那么在 $r$ 固定的情况下，$l$ 显然也是越小越好。那么我们可以得出结论：对于 $l_1<l_2$, 若 $sum[l_1-1]-acl_1<sum[l_2-1]-acl_2$，那么 $l_2$ 是对答案没有贡献的。我们可以遍历一遍数组，计算出 $f[l]=sum[l-1]-acl$ 序列，然后从序列中删除所有对答案没有贡献的元素，最后就会得到一个单调递减的序列 $f$。那么对于这个单调序列，我们就可以用二分搜索来搜索 $l$ 的值。

在具体实现中，我们可以枚举 $r$，那么在单次枚举中 $r$ 就是固定的。在枚举过程中顺便统计 $f[l]=sum[l]-acl$，对于无效的元素，可以将其设置为其前一个有效元素相同的值，这样搜索时就会自动搜索到第一个有效元素了。

代码

附上 AC 代码：

#include <algorithm>
#include <array>
#include <iostream>
using namespace std;
using ll = long long;
const int MAXN = 3e5;
int n;
ll a, b, c;
array<ll, MAXN + 5> s;
array<ll, MAXN + 5> sum;
array<ll, MAXN + 5> f;

int main()
{
    cin >> n >> a >> b >> c;
    for (auto i = 1; i <= n; i++)
    {
        cin >> s.at(i);
        sum.at(i) = s.at(i) + sum.at(i - 1);
    }
    f.at(0)=1e18;
    auto ans=0;
    for (auto i=1; i<=n; i++)
    {
        f.at(i)=min(f.at(i-1),sum.at(i-1)-a*c*i);
        auto l = 1, r = i;
        while (l <= r)
        {
            auto mid = (l + r) / 2;
            if (sum.at(i)-a*b*i>f.at(mid))
            {
                ans=max(ans,i-mid+1);
                r=mid-1;
            }
            else
            {
                l=mid+1;
            }
        }
    }
    cout << ans;
    return 0;
}

[蓝桥杯2024省A]零食采购题解

Thu, 23 Jan 2025 16:11:58 +0800

封面图源 https://www.pixiv.net/artworks/87550307

题目描述

洛谷P10391

小蓝准备去星际旅行，出发前想在本星系采购一些零食，星系内有 $n$ 颗星球，由 $n-1$ 条航路连接为连通图，第 $i$ 颗星球卖第 $c_i$ 种零食特产。小蓝想出了 $q$ 个采购方案，第 $i$ 个方案的起点为星球 $s_i$ ，终点为星球 $t_i$ ，对于每种采购方案，小蓝将从起点走最短的航路到终点，并且可以购买所有经过的星球上的零食（包括起点终点），请计算每种采购方案最多能买多少种不同的零食。

输入格式

输入的第一行包含两个正整数 $n$，$q$，用一个空格分隔。
第二行包含 $n$ 个整数 $c_1,c_2,\cdots, c_n$，相邻整数之间使用一个空格分隔。
接下来 $n - 1$ 行，第 $i$ 行包含两个整数 $u_i,v_i$，用一个空格分隔，表示一条航路将星球 $u_i$ 与 $v_i$ 相连。
接下来 $q$ 行，第 $i$ 行包含两个整数 $s_i , t_i $，用一个空格分隔，表示一个采购方案。

输出格式

输出 $q$ 行，每行包含一个整数，依次表示每个采购方案的答案。

样例 #1

样例输入 #1

样例输出 #1

1
2

3
2

提示

第一个方案路线为 ${4, 2, 1, 3}$，可以买到第 $1, 2, 3$ 种零食；
第二个方案路线为 ${1, 2, 4}$，可以买到第 $1, 2$ 种零食。

对于 20% 的评测用例，$1 ≤ n, q ≤ 5000 $；
对于所有评测用例，$1 ≤ n, q ≤ 10^5，1 ≤ c_i ≤ 20，1 ≤ u_i , v_i ≤ n，1 ≤ s_i , t_i ≤ n$。

解题思路

很简单的 LCA。用倍增 LCA 就可以了，时间复杂度 $O(qlogn)$。有点麻烦的是这个 $ci$ 的处理。朴素 LCA 很好处理这个 $ci$，反正是一个点一个点地回溯的，回溯的时候顺便统计 $ci$ 就好。倍增 LCA 也可以处理路径上的信息，但需要在建树的时候预处理这些信息。在祖先节点数组上记录从该节点到祖先节点（最好是半闭半开区间方便后续统计）所能够买到的所有零食种类，每次扩展祖先节点数组的时候将两个中间祖先的值合并到新祖先上即可。因为每个祖先本质上都是通过父亲扩展而来，因此并不会有遗漏（如果这点有疑问的自己模拟一遍这个过程就明白了）。这要求有一个能够方便地存储所有零食种类和执行合并操作的数据结构。我一开始使用了 unordered_set，用起来非常恶心。看了题解之后发现因为 $c_i$ 的范围较小，可以用 bitset，用了 bitset 马上就 AC 了。

代码

附上通过代码。这道题洛谷的数据终于不犯病了，洛谷和蓝桥杯官网都能过。

#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <list>
#include <vector>
using namespace std;

const int MAXN = 1e5;
const int MAXCI = 20;
using bs = bitset<MAXCI + 5>;
int n, q;
struct node
{
    int c;
    list<int> v;
};
struct tnode
{
    struct father
    {
        int v;
        bs c;
    };
    vector<father> f;
    list<int> s;
    int d;
};
array<node, MAXN + 5> g;
array<tnode, MAXN + 5> tree;

void dfs(int p, int f, int d)
{
    tree.at(p).d = d;
    if (f != 0)
    {
        tree.at(p).f.push_back({f, bs(1 << g.at(p).c)});
    }
    for (auto &i : g.at(p).v)
    {
        if (i != f)
        {
            tree.at(p).s.push_back(i);
        }
    }
    for (auto i = 0; i < tree.at(p).f.size(); i++)
    {
        auto &f1 = tree.at(p).f;
        auto &f2 = tree.at(f1.at(i).v).f;
        if (f2.size() > i)
        {
            f1.push_back(f2.at(i));
            f1.rbegin()->c |= f1.at(i).c;
        }
    }
    for (auto &i : tree.at(p).s)
    {
        dfs(i, p, d + 1);
    }
}
int lca(int s, int t)
{
    bs ans(0);
    while (tree.at(s).d > tree.at(t).d)
    {
        auto logd = static_cast<int>(log2(tree.at(s).d - tree.at(t).d));
        auto &f = tree.at(s).f.at(logd);
        ans |= f.c;
        s = f.v;
    }
    while (tree.at(t).d > tree.at(s).d)
    {
        auto logd = static_cast<int>(log2(tree.at(t).d - tree.at(s).d));
        auto &f = tree.at(t).f.at(logd);
        ans |= f.c;
        t = f.v;
    }
    assert(tree.at(s).d == tree.at(t).d);
    while (s != t)
    {
        auto &f1 = tree.at(s).f;
        auto &f2 = tree.at(t).f;
        auto logd = static_cast<int>(log2(tree.at(s).d));
        for (auto i = logd; i >= 0; i--)
        {
            if (f1.at(i).v == f2.at(i).v)
                continue;
            ans |= f1.at(i).c;
            s = f1.at(i).v;
            ans |= f2.at(i).c;
            t = f2.at(i).v;
        }
        if (f1.begin()->v == f2.begin()->v)
        {
            auto i = 0;
            ans |= f1.at(i).c;
            s = f1.at(i).v;
            ans |= f2.at(i).c;
            t = f2.at(i).v;
            break;
        }
    }
    ans |= (1 << g.at(s).c);
    return ans.count();
}
int main()
{
    cin >> n >> q;
    for (auto i = 1; i <= n; i++)
    {
        int c;
        cin >> c;
        g.at(i).c = c;
    }
    for (auto i = 1; i <= n - 1; i++)
    {
        int u, v;
        cin >> u >> v;
        g.at(u).v.push_back(v);
        g.at(v).v.push_back(u);
    }
    dfs(1, 0, 0);
    for (auto i = 1; i <= q; i++)
    {
        int s, t;
        cin >> s >> t;
        cout << lca(s, t) << endl;
    }
    return 0;
}

[蓝桥杯2024省A]成绩统计题解

Tue, 21 Jan 2025 15:10:48 +0800

封面图源见水印

题目描述

洛谷P10389

小蓝的班上有 $n$ 个人，一次考试之后小蓝想统计同学们的成绩，第 $i$ 名同学的成绩为 $a_i$。当小蓝统计完前 $x$ 名同学的成绩后，他可以从 $1 \sim x$ 中选出任意 $k$ 名同学的成绩，计算出这 $k$ 个成绩的方差。小蓝至少要检查多少个人的成绩，才有可能选出 $k$ 名同学，他们的方差小于一个给定的值 $T$？提示：$k$ 个数 $v_1, v_2, \cdots , v_k$ 的方差 $\sigma^2$ 定义为：$\sigma^2=\dfrac {\sum_{i=1}^k(v_i-\bar v)^2} k$，其中 $\bar v$ 表示 $v_i$ 的平均值，$\bar v = \dfrac {\sum_{i=1}^k v_i} k$。

输入格式

输入的第一行包含三个正整数 $n, k, T $，相邻整数之间使用一个空格分隔。

第二行包含 $n$ 个正整数 $a_1, a2, \cdots, a_n$ ，相邻整数之间使用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。如果不能满足条件，输出 $-1$ 。

样例 #1

样例输入 #1

1
2

5 3 1
3 2 5 2 3

样例输出 #1

提示

检查完前三名同学的成绩后，只能选出 $3, 2, 5 $，方差为 $1.56 $；

检查完前四名同学的成绩后，可以选出 $3, 2, 2 $，方差为 $0.22 < 1 $，所以答案为 $4 $。

对于 $10%$ 的评测用例，保证 $1 ≤ n, k ≤ 10^2$；
对于 $30%$ 的评测用例，保证 $1 ≤ n, k ≤ 10^3$ ；
对于所有评测用例，保证 $1 ≤ n, k ≤ 10^5 $，$1 ≤ T ≤ 2 ^{31} -1 $，$1 ≤ a_i ≤ n $。

解题思路

在蓝桥杯做的第二道二分答案的题，然后我又没做出来 QAQ。

这道题不必过分拘泥于方差如何如何。首先要想到最终答案是要求得一个尽量小的 $x$，$x$ 的二分搜索思路非常简单：二分搜索 $x$，判断是否符合要求，如果符合要求就在左区间继续搜索，否则在右区间搜索。

在确定了这个二分搜索的大方向之后，再考虑如何高效实现判断。要求 $x$ 个数中任意 $k$ 个数的方差，乍看起来复杂度很高，会超时。我最开始也是被这个复杂度吓退了，导致没往这个方向想。但实际上这个复杂度是完全可以接受的。首先在 $x$ 尽量小的基础上，要求方差尽量低，这样才可能小于 $T$。因此容易想到对前 $x$ 个数进行排序，排序之后相邻的数的方差就会比较小。排序的时间复杂度是 $O(nlogn)$。然后就需要挪动一个大小为 $k$ 的窗口，求窗口内的方差。挪动窗口本身是一个接近 $O(n)$ 的复杂度，因此求方差的复杂度不能太高。考虑到我们是在一个挪动的窗口内求方差，尝试通过前缀和进行优化。使用完全平方公式展开求方差的式子，得到 $\sigma^2=\frac{\sum_{i=1}^{k}{v_i^2}-2\sum_{i=1}^{k}{v_i}\bar{v}+k\bar{v}^2}{k}$。其中 $\sum_{i=1}^k{v_i^2}$，$\sum_{i=1}^k{v_i}$ 和 $\bar{v}$ 实际上都可以通过前缀和得到，那么求方差的时间复杂度就是 $O(1)$。那么整个判断的时间复杂度就是排序 $O(nlogn)$ + 求前缀和 $O(n)$ + 挪动窗口求方差 $O(n)$，最终大约是 $O(nlogn)$ 的复杂度。而二分搜索本身是 $O(logn)$ 的复杂度，所以整个算法的复杂度就是 $O(nlog^2n)$。完全在题目要求范围内。

代码

以下附上代码。该代码在蓝桥杯官网通过，但在洛谷无法通过，可能是精度问题。

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
using namespace std;

using ll = long long;
using ld = long double;

int main()
{
    int n, k;
    ld t;
    cin >> n >> k >> t;
    vector<ll> a;
    for (auto i = 0; i < n; i++)
    {
        ll temp;
        cin >> temp;
        a.push_back(temp);
    }
    auto ans = distance(a.begin(), a.end()) + 1;
    auto l = a.begin(), r = a.end();
    while (l < r && distance(a.begin(), r) > k)
    {
        auto m = l + (r - l) / 2;
        vector<ll> b(a.begin(), m + 1);
        sort(b.begin(), b.end());
        vector<ll> sum, powsum;
        bool flag = false;
        for (auto i : b)
        {
            sum.push_back(sum.empty() ? i : i + *sum.crbegin());
            powsum.push_back(powsum.empty() ? i * i : i * i + *powsum.crbegin());
        }
        for (auto i = 0; i + k - 1 < b.size(); i++)
        {
            auto j = i + k - 1;
            auto sumk = sum[j] - (i > 0 ? sum[i - 1] : 0);
            auto powsumk = powsum[j] - (i > 0 ? powsum[i - 1] : 0);
            auto avg = ld(sumk) / k;
            auto var = (powsumk - 2 * sumk * avg + k * avg * avg) / k;
            if (var < t)
            {
                flag = true;
                break;
            }
        }
        if (flag)
        {
            ans = min(distance(a.begin(), m), ans);
            r = m;
        }
        else
        {
            l = m + 1;
        }
    }
    if (ans == distance(a.begin(), a.end()) + 1)
        cout << -1 << endl;
    else
        cout << ans + 1 << endl;
    return 0;
}

[蓝桥杯2023省A]像素放置题解

Sun, 19 Jan 2025 21:36:57 +0800

封面图：https://t.bilibili.com/961668217500073990

题目描述

洛谷P9237

小蓝最近迷上了一款名为《像素放置》的游戏，游戏在一个 $n \times m$ 的网格棋盘上进行，棋盘含有 $n$ 行，每行包含 $m$ 个方格。玩家的任务就是需要对这 $n \times m$ 个方格进行像素填充，填充颜色只有黑色或白色两种。有些方格中会出现一个整数数字 $x(0 \leq x \leq 9)$，这表示当前方格加上周围八个方向上相邻的方格（分别是上方、下方、左方、右方、左上方、右上方、左下方、右下方）共九个方格内有且仅有 $x$ 个方格需要用黑色填充。

玩家需要在满足所有数字约束下对网格进行像素填充，请你帮助小蓝来完成。题目保证所有数据都有解并且解是唯一的。

输入格式

输入的第一行包含两个整数 $n,m$，用一个空格分隔，表示棋盘大小。

接下来 $n$ 行，每行包含 $m$ 个字符，表示棋盘布局。字符可能是数字 $0 \sim 9$，这表示网格上的数字；字符还有可能是下划线（$\text{ASCII}$ 码为 $95$），表示一个不带有数字的普通网格。

输出格式

输出 $n$ 行，每行包含 $m$ 个字符，表示答案。如果网格填充白色则用字符 $0$ 表示，如果网格填充黑色则用字符 $1$ 表示。

样例 #1

样例输入 #1

6 8
_1__5_1_
1_4__42_
3__6__5_
___56___
_688___4
_____6__

样例输出 #1

提示

【样例说明】

上图左是样例数据对应的棋盘布局，上图右是此局游戏的解。例如第 $3$ 行第 $1$ 列处的方格中有一个数字 $3$，它周围有且仅有 $3$ 个格子被黑色填充，分别是第 $3$ 行第 $2$ 列、第 $4$ 行第 $1$ 列和第 $4$ 行第 $2$ 列的方格。

【评测用例规模与约定】

对于 $50 %$ 的评测用例，$1 \leq n,m \leq 5$；

对于所有评测用例，$1 \leq n,m \leq 10$。

解题思路

很简单的深度优先搜索……仅就官方数据而言。实际上深搜的时间复杂度是很危险的，不过官方数据比较水，深搜能全过，洛谷上就会被卡掉几个点。不过也可能是被卡常了。但这道题用搜索性价比还是很高的，写起来比较快也能拿大多数分。

具体做法就是每个点去深搜，从左到右从上到下，每当一个数字周围的点都已经填了 $0$ 或 $1$ 时就检查这个数字是否合法，不合法就直接剪枝。

这么水的解法之所以要写题解，主要是记录一下这张图的存储方法。如果按一般的方法用矩阵存储这张图，那么在判断“一个数字周围的点都已经填了 $0$ 或 $1$”这一步时就会很不优雅。因为在深搜的过程中，并不是按数字周边去深搜的，而是按顺序；因此这一步从判断数字周围的情况，变为了判断当前填入的这个点是否是“某个数字周围最后的点”。很容易想到一个数字周围最后的点应该是它右下角的点，如果它右下角的点已经被填了，那么它周围的所有点应该都被填了。但是这并非绝对，要处理三种特殊情况，即数字在图的最右侧、数字在图的最下方、数字在图的右下角。我在第一次写时就遗漏了最后一种特殊情况，导致只通过了一个点。还有一个陷阱是可能有多个数字会同时需要检查。

要解决这个问题，有两个技巧：

将图建大一圈，避免数组访问越界的问题。注意到统计一个数字周围时，只需要统计周围 $1$ 的个数即可，所以可以在图的周围填一圈 $0$，这样无论边缘还是中心的数字都可以统计周围一圈，不用担心越界问题。
在存储图时，不存储数字，而是存储“检查点”。“检查点”就是上文中提到的“一个数字周围最后的点”。当 DFS 填到“检查点”时，就意味着要触发“检查”。一个数字对应的“检查点”其实就是其右下角的座标和边界取最小值，这样就把复杂的 $8$ 个判断条件简化为 $2$ 个 min 语句，而且在输入时处理即可，搜索算法内部实现可以做到非常简洁。注意到一个座标可能是多个数字的检查点，因此对于每个座标使用一个链表来存储所有检查点，即使用一个链表类型的二维数组来存储这张图。

使用这两个技巧之后，在搜索算法内部不需要添加任何的额外判断，所有数字的处理方法都是一致的。在输入时仅需要加入一行语句来处理边缘点即可。非常优雅。

代码

附上实现代码（该代码蓝桥杯官网全过，洛谷只能92分）：

#include <algorithm>
#include <iostream>
#include <list>
using namespace std;
struct loc
{
    int x, y;
};
struct point
{
    loc l;
    int v;
};
const int MAXN = 15;
const loc NEAR[9] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 0}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
int result[MAXN][MAXN];
int n, m;
list<point> g[MAXN][MAXN];

void printresult()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cout << result[i][j];
        }
        cout << endl;
    }
}
loc add(loc a)
{
    if (a.y == m)
    {
        a.x++;
        a.y = 1;
        return a;
    }
    else
    {
        a.y++;
        return a;
    }
}
bool check(const loc &cur)
{
    for (auto i : g[cur.x][cur.y])
    {
        int &x = i.l.x, &y = i.l.y;
        int sum=0;
        for (auto j:NEAR)
        {
            sum+=result[x+j.x][y+j.y];
        }
        if (sum!=i.v) return false;
    }
    return true;
}
bool dfs(loc cur)
{
    if (cur.x > n || cur.y > m)
    {
        return true;
    }
    result[cur.x][cur.y] = 1;
    if (check(cur))
        if (dfs(add(cur)))
            return true;
    result[cur.x][cur.y] = 0;
    if (check(cur))
        if (dfs(add(cur)))
            return true;
    return false;
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            char c;
            do
            {
                c = getchar();
            } while (c != 95 && (c < '0' || c > '9'));
            if (c >= '0' && c <= '9')
            {
                int x = min(i + 1, n), y = min(j + 1, m);
                g[x][y].push_back({{i, j}, c - '0'});
            }
        }
    }
    dfs({1, 1});
    printresult();
    return 0;
}

[蓝桥杯2023省A]异或和之和题解

Sat, 18 Jan 2025 16:50:42 +0800

如果您知道封面图出处，请在评论区留言。

题目描述

洛谷P9236

给定一个数组 $A_i$，分别求其每个子段的异或和，并求出它们的和。或者说，对于每组满足 $1 \leq L \leq R \leq n$ 的 $L,R$，求出数组中第 $L$ 至第 $R$ 个元素的异或和。然后输出每组 $L,R$ 得到的结果加起来的值。

输入格式

输入的第一行包含一个整数 $n$ 。

第二行包含 $n$ 个整数 $A_i$，相邻整数之间使用一个空格分隔。

输出格式

输出一行包含一个整数表示答案。

样例 #1

样例输入 #1

1
2

5
1 2 3 4 5

样例输出 #1

提示

【评测用例规模与约定】

对于 $30 %$ 的评测用例，$n \leq 300$；

对于 $60 %$ 的评测用例，$n \leq 5000$;

对于所有评测用例，$1 \leq n \leq 10^5$，$0 \leq A_i \leq 2^{20}$。

解题思路

首先想到前缀和，然后枚举 $L$ 和 $R$ ，时间复杂度 $O(n^2)$ ，代码非常简单，可以拿下60分。代码如下：

#include <iostream>
using namespace std;
const int MAXN=100000;
int n,a[MAXN+5];
int sum[MAXN+5];

int main()
{
    cin>>n;
    for (int i=1;i<=n;i++)
    {
        cin>>a[i];
        if (i>=1)
        {
            sum[i]=a[i]^sum[i-1];
        }
    }
    long long ans=0;
    for (int l=1;l<=n;l++)
    {
        for (int r=l;r<=n;r++)
        {
            ans+=sum[r]^sum[l-1];
        }
    }
    cout<<ans;
    return 0;
}

注意 ans 需要开 long long

常规做法到这里就是极限了。如果要继续优化，就需要从异或运算的性质入手。位运算中，每个位的运算结果只与当前位有关，所以可以使用“拆位”的技巧，将位拆出来单独处理。注意到

    for (int l=1;l<=n;l++)
    {
        for (int r=l;r<=n;r++)
        {
            ans+=sum[r]^sum[l-1];
        }
    }

这段代码实际上是将 sum 数组中的元素两两异或然后求和。每个元素恰好都与其它元素异或 $1$ 次。求和运算中，只有异或之后值为 $1$ 的位对求和运算有影响，表现为异或前两个操作数在该位上相异。因此可以这样考虑：使用一个新的数组 w[][2] 来统计每个位上 $0$ 和 $1$ 的数目，那么 w[i][0]*w[i][1] 实际上就是两两异或的过程中，该位的结果会产生的 $1$ 的个数（相应的，会产生 $0$ 的个数应该为 w[i][0]*w[i][0]+w[i][1]*w[i][1]）。这个数再乘上当前位的位权，就是它最终对 ans 做的贡献。也就是说，$ans=\sum_{i=0}^{20}{w[i][0]\times w[i][1]\times 2^i}$ 这里累加下标从 $0$ 开始，是因为当 l=0 时，sum[0] 会参与异或。而上界 $20$ 是根据数据范围。

由此很容易得到最终代码。注意循环范围和求和中的溢出问题。

代码

附上通过代码：

#include <array>
#include <iostream>
using namespace std;
const int MAXN = 100000;
int n;
array<int, MAXN + 5> sum, a;
int w[25][2];

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        sum[i] = a[i] ^ sum[i - 1];
    }
    long long ans = 0;
    for (int i = 0; i <= n; i++)
    {
        for (int j = 0; j <= 20; j++)
        {
            w[j][(sum[i]>>j)&1]++;
        }
    }
    for (int i = 0; i <= 20; i++)
    {
        ans += (long long)w[i][0] * w[i][1] * (1 << i);
    }
    cout << ans;
    return 0;
}

[蓝桥杯2023省A]网络稳定性题解

Sat, 18 Jan 2025 11:01:57 +0800

封面图：https://www.pixiv.net/artworks/126215041

题目描述

洛谷P9235

有一个局域网，由 $n$ 个设备和 $m$ 条物理连接组成，第 $i$ 条连接的稳定性为 $w_i$。

对于从设备 $A$ 到设备 $B$ 的一条经过了若干个物理连接的路径，我们记这条路径的稳定性为其经过所有连接中稳定性最低的那个。

我们记设备 $A$ 到设备 $B$ 之间通信的稳定性为 $A$ 至 $B$ 的所有可行路径的稳定性中最高的那一条。

给定局域网中的设备的物理连接情况，求出若干组设备 $x_i$ 和 $y_i$ 之间的通信稳定性。如果两台设备之间不存在任何路径，请输出 $-1$。

输入格式

输入的第一行包含三个整数 $n,m,q$，分别表示设备数、物理连接数和询问数。

接下来 $m$ 行，每行包含三个整数 $u_i,v_i,w_i$，分别表示 $u_i$ 和 $v_i$ 之间有一条稳定性为 $w_i$ 的物理连接。

接下来 $q$ 行，每行包含两个整数 $x_i,y_i$，表示查询 $x_i$ 和 $y_i$ 之间的通信稳定性。

输出格式

输出 $q$ 行，每行包含一个整数依次表示每个询问的答案。

样例 #1

样例输入 #1

样例输出 #1

1
2
3

-1
3
5

提示

【评测用例规模与约定】

对于 $30 %$ 的评测用例，$n,q \leq 500$，$m \leq 1000$；

对于 $60 %$ 的评测用例，$n,q \leq 5000$，$m \leq 10000$；

对于所有评测用例，$2 \leq n,q \leq 10^5$，$1 \leq m \leq 3 \times 10^5$，$1 \leq u_i,v_i,x_i,y_i \leq n$，$ 1 \leq w_i \leq 10^6$，$u_i \neq v_i$，$x_i \neq y_i$。

解题思路

这道题最开始很容易往最短路的方向想，但是最短路的复杂度是 $O(n^3)$，对于 $n \leq 10^5$ 的数据量是不可接受的。

注意到路径的稳定性与路径中经过的单条边的边权有关，但与整条路径的长度无关。因此其实可以对每条边做贪心，而不需要像最短路一样计算整条路径的长度。又因为两个设备之间的稳定性为所有可行路径中稳定性最高的一条，因此贪心的策略就是要不断取稳定性高的边，直到设备之间连通起来。这实际上是“最大生成树”。其算法可以采用和最小生成树一样的算法。这样处理之后，我们就可以剪去很多无用的路径，从图中生成几颗“最大生成树”（注意到这不一定是连通图，因此可能得到多颗生成树）。在同一颗生成树内的就是互相连通的，否则不能到达。这可以通过求生成树过程中的并查集来判断。

生成了树之后，就要考虑如何高效地处理查询。尽管经过剪枝，图的路径数已经大大降低了，但每个查询跑一遍搜索大概还是不能接受的。考虑到这是一棵树，可以使用最近公共祖先算法，让两个叶子节点同时向根部回溯直到相遇，记录下回溯过程中经过的最小边权即为答案。

具体实现上，最小生成树算法并不能实际给到一个树的数据结构，只能得到一张有向无环图。可以在算法过程中处理来得到树，我这里直接选择在有向无环图上跑一遍dfs来生成树，时间复杂度 $O(n)$ 。朴素 LCA 的时间复杂度是 $O(n)$ ，每次查询都跑一遍的话最后一个点会超时，需要使用倍增 LCA，倍增 LCA 需要注意倍增的上界，避免数组越界问题。

代码

最后附上代码：

#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <list>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
const int MAXN = 100000, MAXQ = 100000, MAXM = 300000, MAXW = 1000000;
struct edge
{
    int u, v, w;
    bool operator<(const edge &other) const
    {
        return w < other.w;
    }
    bool operator>(const edge &other) const
    {
        return w > other.w;
    }
    bool operator==(const edge &other) const
    {
        return w == other.w;
    }
};
struct ledge
{
    int to, w;
};
struct lnode
{
    list<ledge> e;
};
struct tnode
{
    vector<ledge> fa;
    list<ledge> son;
    int d = -1;
} tree[MAXN + 5];
class ufset
{
    struct ufnode
    {
        int f = -1, d = 1;
    };
    vector<ufnode> node;

  public:
    ufset(int n)
    {
        node.resize(n);
    }
    int find(int a)
    {
        if (node[a].f == -1)
            return a;
        else
            return node[a].f = find(node[a].f);
    }
    int uni(int a, int b)
    {
        a = find(a);
        b = find(b);
        if (a == b)
            return -1;
        if (node[a].d < node[b].d)
            node[a].f = b;
        else
        {
            if (node[a].d == node[b].d)
            {
                node[a].f = b;
                node[b].d++;
            }
            else
            {
                node[b].f = a;
            }
        }
        return 0;
    }
} uf(MAXN + 5);
int n, m, q;

void dfs(int cur, int fa, int d, const vector<lnode> &ln)
{
    tree[cur].d = d;
    for (auto i:ln[cur].e)
    {
        if (fa != -1 && i.to == fa)
        {
            tree[cur].fa.push_back(i);
        }
        else
        {
            tree[cur].son.push_back(i);
        }
    }
    for (int i = 0; i < tree[cur].fa.size(); i++)
    {
        int fa = tree[cur].fa[i].to;
        if (tree[fa].fa.size() <= i)
            break;
        tree[cur].fa.push_back({tree[fa].fa[i].to, min(tree[fa].fa[i].w, tree[cur].fa[i].w)});
    }
    for (auto i : tree[cur].son)
    {
        dfs(i.to, cur, d + 1, ln);
    }
}
void gen_tree()
{
    priority_queue<edge> e;
    for (int i = 0; i < m; i++)
    {
        edge ei;
        cin >> ei.u >> ei.v >> ei.w;
        e.push(std::move(ei));
    }
    int sum = 0;
    vector<lnode> ln(n + 5);
    while (sum < n - 1 && !e.empty())
    {
        edge ei = e.top();
        e.pop();
        if (uf.uni(ei.u, ei.v) == -1)
            continue;
        sum++;
        ln[ei.u].e.push_back({ei.v, ei.w});
        ln[ei.v].e.push_back({ei.u, ei.w});
    }
    for (int i = 1; i <= n; i++)
    {
        if (tree[i].d == -1)
        {
            dfs(i, -1, 0, ln);
        }
    }
}
int lca(int u, int v)
{
    int ans = MAXW + 5;
    while (tree[u].d > tree[v].d)
    {
        int d = log2(tree[u].d - tree[v].d);
        ans = min(tree[u].fa[d].w, ans);
        u = tree[u].fa[d].to;
    }
    while (tree[v].d > tree[u].d)
    {
        int d = log2(tree[v].d - tree[u].d);
        ans = min(tree[v].fa[d].w, ans);
        v = tree[v].fa[d].to;
    }
    assert(tree[u].d == tree[v].d);
    if (u == v)
        return ans;
    while (tree[u].fa[0].to != tree[v].fa[0].to)
    {
        int logd = log2(tree[u].d);
        for (int i = logd; i >= 0; i--)
        {
            if (tree[u].fa[i].to == tree[v].fa[i].to)
                continue;
            ans = min(min(ans, tree[u].fa[i].w), tree[v].fa[i].w);
            u = tree[u].fa[i].to;
            v = tree[v].fa[i].to;
            break;
        }
    }
    ans = min(min(ans, tree[u].fa[0].w), tree[v].fa[0].w);
    return ans;
}
void ans()
{
    for (int i = 0; i < q; i++)
    {
        int u, v;
        cin >> u >> v;
        if (uf.find(u) != uf.find(v))
        {
            cout << -1 << endl;
            continue;
        }
        cout << lca(u, v) << endl;
    }
}

int main()
{
    cin >> n >> m >> q;
    gen_tree();
    ans();
    return 0;
}

树上启发式合并

Fri, 06 Sep 2024 20:37:21 +0800

封面图：https://www.bilibili.com/opus/977994994306514949

引言

树上启发式合并的算法本身并不难，更值得关注的是它的时间复杂度。启发式算法的时间复杂度通常比较玄学，然而在树上启发式合并中，我们可以看到启发式算法是如何极大优化时间复杂度的。本文将通过一道蓝桥杯的题目来讲解树上启发式合并的算法，并分析它的时间复杂度。

例题

洛谷P9233

[蓝桥杯 2023 省 A] 颜色平衡树

题目描述

给定一棵树，结点由 $1$ 至 $n$ 编号，其中结点 $1$ 是树根。树的每个点有一个颜色 $C_i$。

如果一棵树中存在的每种颜色的结点个数都相同，则我们称它是一棵颜色平衡树。

求出这棵树中有多少个子树是颜色平衡树。

输入格式

输入的第一行包含一个整数 $n$，表示树的结点数。

接下来 $n$ 行，每行包含两个整数 $C_i,F_i$，用一个空格分隔，表示第 $i$ 个结点的颜色和父亲结点编号。

特别地，输入数据保证 $F_1$ 为 $0$，也即 $1$ 号点没有父亲结点。保证输入数据是一棵树。

输出格式

输出一行包含一个整数表示答案。

样例 #1

样例输入 #1

样例输出 #1

提示

【样例说明】

编号为 $1,3,5,6$ 的 $4$ 个结点对应的子树为颜色平衡树。

【评测用例规模与约定】

对于 $30 %$ 的评测用例，$n \leq 200$，$C_i \leq 200$；

对于 $60 %$ 的评测用例，$n \leq 5000$，$C_i \leq 5000$；

对于所有评测用例，$1 \leq n \leq 200000$，$1 \leq C_i \leq 200000$，$0 \leq F_i<i$。

题解

注意到该题是一道数据离线的树上数颜色的问题。首先可以想到用 dfs ，枚举每一颗子树，分别进行dfs统计颜色数量，然后判断是否是颜色平衡树。但是这样的时间复杂度是 $O(n^2)$ 的，显然不可接受。

注意到在这种算法中，有些点被重复计算了很多次。能不能减少点被计算的次数呢？很容易想到对于一颗子树，如果它的儿子的子树已经统计过了，那么它只需要直接合并儿子的统计结果就可以了。我们可以用一个桶数组来存储每个颜色出现的次数。颜色数量很多，不能为每个点开一个桶，也不能使用 memset 和 memcpy 来初始化和合并桶数组。很容易想到为子节点和父节点分别开一个桶，对于每颗子树，扫描三次，第一次统计子节点的颜色数量到子节点桶，第二次合并子节点的颜色数量到父节点，第三次清除子节点桶以供兄弟节点使用。每次一层统计完时，就交换子节点桶和父节点桶。这样子未免有点麻烦，其实可以只使用一个数组。每个子树依然扫描三次，第一次统计子节点的颜色数量到数组，第二次清除数组以供兄弟节点使用。在所有兄弟节点用完一遍之后，再统计一次子节点的颜色数量到数组。这样就能统计所有子树的颜色数量给到父节点了。

在实现以上算法时，很容易想到的一个优化是在最后一个兄弟节点使用数组时，可以不用清除数组。直接将其它兄弟节点的颜色数量合并到数组上，这样就能免除这个兄弟节点的清除和重新加入数组两边遍历操作。这个优化的效果很大程度上取决于这个“最后一个兄弟节点”的选择。显然，如果我们能够选择一个“最后一个兄弟节点”，使得它的子节点数量最多，那么这个优化的效果就会最大。这就是启发式合并的核心思想。

时间复杂度思考

在这个算法中，一个节点仍然会被遍历多次。在一层中，一个轻节点会被遍历 3 次，一个重节点会被遍历 1 次。轻节点的儿子也会因为轻节点的需要而被遍历多次。但是，重节点却没有这样的问题。当我们分析时间复杂度时，我们可以从每个节点的角度来分析。对于每一个节点，它被遍历到的次数最多是 $O(\log n)$ 的。我们可以从它的轻节点祖先数量来思考。一个节点如果是轻节点，那么它的子树的节点数量一定小于它的父节点的子树的节点数量的一半（如果超过一半，那么它就是重节点了）。由此，从根节点到某个节点，每经过一条轻边，节点的子树的节点数量就会减少一半。所以，一个节点的轻节点祖先数量最多是 $O(\log n)$ 的（否则总节点数就要超过 $n$ 了）。所以整体的时间复杂度是 $O(n\log n)$ 的。

从以上思考可以看出，树上启发式合并确保了每个节点的遍历次数是 $O(\log n)$ 的，这是由树的性质和一个简单的启发式操作决定的。如果不使用启发式合并，那么最糟糕的情况下，时间复杂度仍然会接近 $O(n^2)$。

代码实现

#include<iostream>
#include<vector>
using namespace std;
const int MAXN=200005,MAXC=200005;
int n,ans=0;
int color[MAXN],cnt[MAXC],ccnt[MAXN],ns[MAXN];
vector<int>son[MAXN];
int chson(int node);
void dfs(int node);
void add(int node,int delta);
int chson(int node)
{
    int result=1;
    for (auto &i:son[node])
    {
        ns[i]=chson(i);
        result+=ns[i];
        if (ns[i]>ns[son[node][0]])
        {
            swap(i,son[node][0]);
        }
    }
    return result;
}
void dfs(int node)
{
    for (auto i=son[node].begin()+1;i<son[node].end();i++)
    {
        dfs(*i);
        add(*i,-1);
    }
    if (son[node].size()>0) dfs(son[node][0]);
    ccnt[cnt[color[node]]]--;
    cnt[color[node]]++;
    ccnt[cnt[color[node]]]++;
    for (auto i=son[node].begin()+1;i<son[node].end();i++)
    {
        add(*i,1);
    }
    if (cnt[color[node]]*ccnt[cnt[color[node]]]==ns[node]) ans++;
}
void add(int node,int delta)
{
    ccnt[cnt[color[node]]]--;
    cnt[color[node]]+=delta;
    ccnt[cnt[color[node]]]++;
    for (auto i:son[node])
    {
        add(i,delta);
    }
}
int main()
{
    cin>>n;
    for (int i=1;i<=n;i++)
    {
        int c,f;
        cin>>c>>f;
        color[i]=c;
        if (f!=0) son[f].push_back(i);
    }
    ns[1]=chson(1);
    dfs(1);
    cout<<ans;
}

幂的计算方法

Thu, 29 Aug 2024 20:18:56 +0800

封面图：https://www.bilibili.com/opus/967606108335112258

前言

本篇介绍一些算法竞赛中常见的幂的计算方法。本篇并不重点介绍快速幂等基本算法，而是针对一些特殊情况，介绍一些可用于优化的数学定理，以在快速幂的时间复杂度都无法满足题目要求的情况下，进一步优化算法。

前置知识

同余的运算性质

设 $m$ 是一个正整数，$a_1, a_2, b_1, b_2$ 是 $4$ 个整数。如果 $$ a_1 \equiv b_1 \pmod{m}, \quad a_2 \equiv b_2 \pmod{m} $$ 则

$a_1 + a_2 \equiv b_1 + b_2 \pmod{m}$
$a_1 \cdot a_2 \equiv b_1 \cdot b_2 \pmod{m}$

需要注意的是，同余的运算性质中没有针对除法的性质。

快速幂

C++ 本身有提供 pow() 函数，但该函数是浮点数的幂运算，且不支持取模运算。在竞赛中，我们常常遇到大整数的幂运算和模幂运算，这需要自己实现快速幂算法。

Python 的 pow() 函数支持大整数的幂运算和模幂运算，且在我的测试中，速度比自己实现的快速幂要快。因此，如果是 Python 选手，建议直接使用 pow() 函数。

常见的快速幂算法，也就是模重复平方算法。快速模幂运算的解释，网络上有很多，不是本文的重点。简单来说，快速幂就是将指数表示成二进制（$2^n+2^{n-1}+…+2^1+2^0$）的形式，然后通过不断平方基数来减少乘法的次数。以下是一个简单的快速幂的实现：

long long quick_pow(long long a, long long b, long long mod) {
    long long ans = 1;
    while (b) {
        if (b & 1) {
            ans = ans * a % mod;
        }
        a = a * a % mod;
        b >>= 1;
    }
    return ans;
}

快速计算模幂运算的算法不只这一种。针对这一种算法，也有一些常数级别的优化方法。如果感兴趣，也可以自行了解其他算法。

欧拉函数

欧拉函数 $\varphi(n)$ 表示小于等于 $n$ 的正整数中与 $n$ 互质的数的个数。

欧拉函数的性质

如果 $p$ 是质数，则 $\varphi(p) = p - 1$
如果 $p$ 是质数，则 $\varphi(p^k) = p^k - p^{k-1}$
设 $m,n$ 是互质的两个正整数，则 $\varphi(mn) = \varphi(m) \cdot \varphi(n)$。特别地，如果 $m,n$ 是质数，则 $\varphi(mn) = (m-1)(n-1)$
设正整数 $m$ 的标准因数分解式为 $m = \underset{p|m}{\prod} p^k = p_1^{k_1} \cdot p_2^{k_2} \cdot \cdots \cdot p_n^{k_n}$，则 $\varphi(m) = \underset{p|m}{\prod}\varphi(p^k) = m\underset{p|m}{\prod}(1-\frac{1}{p}) = m \cdot (1 - \frac{1}{p_1}) \cdot (1 - \frac{1}{p_2}) \cdot \cdots \cdot (1 - \frac{1}{p_n})$
设 $m$ 是一个正整数，则 $\underset{d|m}{\sum} \varphi(d) = m$。

以下给出求解欧拉函数的 C++ 代码，该代码利用了性质4和性质2：

long long phi(long long a)
{
    long long result = a;
    for (int i = 2; i * i <= a; i++)
    {
        if (a % i == 0)
        {
            while (a % i == 0)
                a /= i;
            result -= result / i;
        }
    }
    if (a > 1)
        result -= result / a;
    return result;
}

幂的计算方法

欧拉定理

设 $m$ 是大于 $1$ 的正整数，$a$ 是与 $m$ 互质的整数，则 $$ a^{\varphi(m)} \equiv 1 \pmod{m} $$ 该定理提示了，如果题目中存在条件基数 $a$ 和模数 $m$ 互质，那么指数 $k$ 就可以简化为 $k \mod{\varphi(m)}$。

费马小定理

设 $p$ 是一个质数，则对任意整数 $a$，有 $$ a^p \equiv a \pmod{p} $$ 推论：设 $p$ 是一个质数，则对任意整数 $a$，以及对任意正整数 $t,k$，有 $$ a^{k \cdot (p-1) + t} \equiv a^t \pmod{p} $$ 该推论提示了，如果题目中存在条件模数 $p$ 为质数，那么指数 $k$ 就可以简化为 $k \mod{(p-1)}$。容易发现，费马小定理是欧拉定理在模数为质数时的特殊情况。

拓展欧拉定理

欧拉定理要求基数 $a$ 与模数 $m$ 互质，而拓展欧拉定理则放宽了这一条件。设 $m$ 是大于 $1$ 的正整数，$a$ 是任意整数，$k \geq \varphi(m)$，则 $$ a^k \equiv a^{k \mod{\varphi(m)} + \varphi(m)} \pmod{m} $$ 如果 $k<\varphi(m)$，那么只需要直接计算 $a^k$ 即可。该定理去除了欧拉定理中 $a$ 与 $m$ 互质的要求。因此，通过扩展欧拉定理，我们就能将几乎所有情况下的指数简化到小于 $2\varphi(m)$。

实操演练

洛谷P10414

[蓝桥杯 2023 国 A] 2023 次方

题目描述

求 $2^{(3^{(4^{(\ldots ^{2023}})})}$ 的值对 $2023$ 取模的结果。

注: 上式都是指数，可写为 $2** (3**(4**(\ldots 2023\ldots))$ 其中 $**$ 表示指数。

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

输入格式

输出格式

解题思路

注意到，$2023=7 \times 17 \times 17$，并非质数；通过计算可知，$\varphi(2023)=1632$，而 $gcd(3,1632)\neq 1$。因此，不能使用费马小定理和欧拉定理。考虑使用扩展欧拉定理求解。本题目中要求解的算式也比较复杂，建议动手算算前几项来确定递归关系。

代码实现

#include <iostream>
using namespace std;
const int n = 2023, mod = 2023;
int phim;
long long phi(long long a)
{
    long long result = a;
    for (int i = 2; i * i <= a; i++)
    {
        if (a % i == 0)
        {
            while (a % i == 0)
                a /= i;
            result -= result / i;
        }
    }
    if (a > 1)
        result -= result / a;
    return result;
}
long long fpow(long long a, long long b, long long mod)
{
    long long ans = 1;
    while (b > 0)
    {
        if (b & 1)
            ans = ans * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ans;
}
long long f(long long a, long long m)
{
    if (a == n)
        return a;
    long long phim = phi(m);
    return fpow(a, f(a + 1, phim) + phim, m);
}
int main()
{
    cout << f(2, mod);
}

卡特兰数学习笔记

Sun, 25 Aug 2024 11:12:34 +0800

封面图：https://www.miyoushe.com/bh3/article/53423106

应用背景

用到卡特兰数的经典问题有：

括号匹配问题：计算 $n$ 对括号正确配对的方案数。
二叉树计数：计算有 $n$ 个内部节点（非叶节点）的二叉树的不同形态数。
路径计数：在格点中，从原点到 $(2n, 0)$ 点，不穿过对角线的路径数。
分割问题：将一个凸多边形分割成n个三角形的不同方法数。
括号表达式：计算包含n对括号和n个不同运算符的有效算术表达式的数量。
栈操作：给定一系列进栈和出栈操作，计算不违反栈原则的操作序列数。

当你拿到一个问题时，你可以通过以下步骤来确定它是否能用卡特兰数来解决：

递推关系：如果问题的解决方案可以分解为两个子问题，并且这两个子问题的解的乘积构成了原问题的解，特别地，递推公式形如 $H_n=\sum_{k=0}^{n-1}H_kH_{n-1-k}$ 那么这个问题可能可以用卡特兰数来解决。
对称性：卡特兰数通常出现在具有某种对称性的问题中。如果问题具有对称性，这可能是一个线索。
排除非法状态：许多卡特兰数问题都涉及到在构建过程中排除非法状态。例如，在括号匹配问题中，不能出现右括号多于左括号的情况。
计数问题：卡特兰数通常用于计数问题，尤其是那些涉及到某种“平衡”或“结构”的问题。
匹配和划分：如果问题是关于如何匹配或划分对象，且匹配或划分需要遵循特定的规则，那么它可能可以用卡特兰数来解决。
找规律：可以在小的数据规模上计算问题的答案，如果发现问题的答案与卡特兰数的前几项 $1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862$ 相同，那么该问题可能可以用卡特兰数来解决。

例题引入

我们通过两个例题来引入卡特兰数的计算方法。

如图，从格点 $(0,0)$ 走到格点 $(n,n)$ ，只能向右或向上走，且不能穿过对角线，求路径数。

先不考虑对角线的限制。从格点 $(0,0)$ 到格点 $(n,n)$ ，因为只能向右或者向上，所以只能是 $n$ 步向右，$n$ 步向上，总共要走 $2n$ 步。我们可以从 $2n$ 步中任选 $n$ 步向右，剩下 $n$ 步向上，就能组成一条路径。所以路径总数为 $C_{2n}^n$。

之后考虑这些路径中穿过了对角线的路径数。可以画一条线为 $y=x+1$，所有穿过了对角线的路径必然与这条线相交，而没有穿过对角线的路径必然不与这条线相交。我们假设穿过了对角线的路径与该线的交点为P，将P点右侧的路径以 $y=x+1$ 为对称轴进行对称，注意到 $(n,n)$ 的对称点是 $(n-1,n+1)$，所以就可以得到一条连接 $(0,0)$ 和 $(n-1,n+1)$ 的路径。如下图所示。对称地思考，连接 $(0,0)$ 和 $(n-1,n+1)$ 的路径数就等于所有穿过了对角线的路径数，即 $C_{2n}^{n-1}$。

所以答案就是 $C_{2n}^n-C_{2n}^{n-1}$。这就是卡特兰数的一个通项公式。

接下来我们从另一个角度来推出卡特兰数。考虑凸多边形的划分问题。将一个凸 $n$ 边形的顶点从0到n-1进行编号，之后将其划分成 $n-2$ 个三角形，如图，求划分方法数。

我们可以任取一个点k，将多边形划分成三角形 $0,k,n-1$和两个多边形，分别是 $0,1,…,k$ 和 $k,k+1,…,n-1$。这两个多边形的边数分别是 $k+1$ 和 $n-k$，那么划分方法数就是将这两个多边形分别划分的方法数的乘积。所以得到递推关系 $f_n=\sum_{k=1}^{n-2}f_{k+1}f_{n-k}$，其中 $f_2=1$。该数列是从2开始的，我们不妨令 $H_n=f_{n+2}=\sum_{k=1}^{n}f_{k+1}f_{n+2-k}=\sum_{k=1}^{n}H_{k-1}H_{n-k}=\sum_{k=0}^{n-1}H_kH_{n-1-k}$，其中 $H_0=1$。我们可以求出 $H_n$ 的前几项，可以发现它和上一道题的 $C_n$ 是同一个数列。因此，这就是卡特兰数的递推公式。从该递推公式严谨地推导通项公式并不容易，这里就不展开了。

卡特兰数的通项公式

卡特兰数的常用通项公式有：

$$ H_n=C_{2n}^n-C_{2n}^{n-1} $$

$$ H_n=\frac{1}{n+1}C_{2n}^n $$

常用的递推公式有：

$$ H_n=\frac{4n-2}{n+1}H_{n-1} $$

这些公式之间的转换推导很简单，这里就不展开了。在实际应用中，卡特兰数也经常会以上文中例题2的形式出现。但是例题2的形式不太方便计算，我们可以通过递推式计算出答案的前几项，找到它和通项公式的对应关系，之后用通项公式求解。

在实际计算中，我们常常不能直接计算 $C_{2n}^n$，而往往也采用递推的方式计算组合数。因此，以上的公式在实际应用时通常都表现为递推的形式。

实操演练

洛谷P10413

[蓝桥杯 2023 国 A] 圆上的连线

题目描述

给定一个圆，圆上有 $n=2023$ 个点从 $1$ 到 $n$ 依次编号。

问有多少种不同的连线方式，使得完全没有连线相交。当两个方案连线的数量不同或任何一个点连接的点在另一个方案中编号不同时，两个方案视为不同。

答案可能很大，请将答案对 $2023$ 求余后提交。

输入格式

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

输出格式

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

解题思路

这道题是卡特兰数的变式。首先它没有要求所有点都要连线，因此我们首先要确定连线的点的数量。连线的点必须是偶数个，因此，挑选点的方案数是 $C_{2023}^{2k}, 1 \leq k \leq \frac{2023}{2}, k\in N$。此时参与连线的点的数量为 $2k$。因为要求连线不能相交，那么一条连线可以将圆分成两个部分，这两个部分的连线方式是独立的。并且为了确保两个部分都能合法地连线，两个部分包含的点的数量都必须是偶数。大圆的连线方案数就是两个部分的连线方案数的乘积。这里就能看出是一个卡特兰数的问题。不妨将选中的点中编号最低的点 $p$ 固定，然后选择 $p+2i+1$ 和其连线，那么连线就将剩余的点分为 $2i$ 和 $2k-2i-2$ 两个部分。假设 $2k$ 个点的连线方案数为 $H_{k}$，那么递推关系为 $H_{k}=\sum_{i=0}^{k-1}H_{i}H_{k-i-1}$，也就是卡特兰数的递推公式。最后，答案还需要乘上挑选点的方案数，因此，最终结果是 $ans=\sum_{k=1}^{1011}C_{2023}^{2k}H_{k}$。

在实际编程时，我选择 $H_n=C_{2n}^n-C_{2n}^{n-1}$ 的形式来计算卡特兰数。注意题目要求对 $2023$ 求余，因此我们需要谨慎挑选计算组合数的方法。在这里我使用了 $C_{n}^{m}=C_{n-1}^{m-1}+C_{n-1}^{m}$ 的递推式来计算组合数。

源代码

#include <iostream>
using namespace std;
const int n = 2023, m = 2023;
long long c[n + 5][n + 5];
int main()
{
    c[0][0]=1;
    for (long long i = 1; i <= n; i++)
    {
        c[i][0] = 1;
        for (long long j = 1; j <= i; j++)
            c[i][j] = (c[i-1][j-1] + c[i-1][j] )%m;
    }
    int ans = 0;
    for (int i = 0; i <= 2023; i += 2)
    {
        int h = c[i][i / 2] - c[i][i / 2 - 1];
        ans+=c[n][i]*h%m;
        ans%=m;
    }
    cout << ans;
    return 0;
}

[蓝桥杯2023国A]01游戏题解

Tue, 20 Aug 2024 21:09:39 +0800

封面图：https://www.bilibili.com/opus/967606108335112258

题目描述

洛谷P10419

小蓝最近玩上了 $01$ 游戏，这是一款带有二进制思想的棋子游戏，具体来说游戏在一个大小为 $N\times N$ 的棋盘上进行，棋盘上每个位置都需要放置一位数字 $0$ 或者数字 $1$，初始情况下，棋盘上有一部分位置已经被放置好了固定的数字，玩家不可以再进行更改。玩家需要在其他所有的空白位置放置数字，并使得最终结果满足以下条件：

所有的空白位置都需要放置一个数字 $0/1$；
在水平或者垂直方向上，相同的数字不可以连续出现大于两次；
每一行和每一列上，数字 $0$ 和数字 $1$ 的数量必须是相等的 (例如 $N=4$，则表示每一行/列中都需要有 $2$ 个 $0$ 和 $2$ 个 $1$)；
每一行都是唯一的，因此每一行都不会和另一行完全相同；同理每一列也都是唯一的，每一列都不会和另一列完全相同。

现在请你和小蓝一起解决 $01$ 游戏吧！题目保证所有的测试数据都拥有一个唯一的答案。

输入格式

输入的第一行包含一个整数 $N$ 表示棋盘大小。

接下来 $N$ 行每行包含 $N$ 个字符，字符只可能是 0、1、_ 中的其中一个 (ASCII 码分别为 $48$，$49$，$95$)，0 表示这个位置数字固定为 $0$，1 表示这个位置数字固定为 $1$，_ 表示这是一个空白位置，由玩家填充。

输出格式

输出 $N$ 行每行包含 $N$ 个字符表示题目的解，其中的字符只能是 0 或者 1。

样例 #1

样例输入 #1

6
_0____
____01
__1__1
__1_0_
______
__1___

样例输出 #1

提示

【评测用例规模与约定】

对于 $60%$ 的评测用例，$2\le N\le 6$;
对于所有评测用例，$2\le N\le 10$，$N$ 为偶数。

感谢 @rui_er 提供测试数据。

解题思路

这道题的题目数据比较弱，虽然生成二进制数然后按行填入的方法比较快，但是用一位一位填数的方法也能过洛谷的评测。

剪枝技巧非常简单：

记录每一行和每一列 $0$ 和 $1$ 的个数，仅当有余量的时候允许填 $0$ 或者填 $1$。
在每行填完的时候进行合法性检查：
1. 检查当前行是否有连续3个 $0$ 或 $1$；
2. 检查是否有行重复；
3. 检查已经填入的数字中，是否有某一列出现了重复的 $0$ 或 $1$。

我最开始实现的时候为了追求更快的剪枝，还希望在每填一个数的时候，通过检查该位置前后的数字，来确保该位置只填入合法的数字。比如，如果该位置前面已经有两个 $0$ 了，就直接填 $1$。但是实际实现下来这需要考虑非常多的情况，仅单个数字出现重复的情况就有6种，还要考虑到两个数字都出现重复的情况，比如 $11\_00$。这样子判断条件就很复杂，很容易出错，而且效果不理想。经验教训就是不要考虑太过复杂，收益也不高的剪枝吧。

代码

最后附上代码：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int MAXN = 11;
struct coord
{
    int x, y;
    coord move(int n) const
    {
        if (y < n - 1)
            return {x, y + 1};
        else
            return {x + 1, 0};
    }
};
char a[MAXN][MAXN];
int r[MAXN][2], c[MAXN][2];
int n;
bool checkc()
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < i; j++)
        {
            bool flag = true;
            for (int k = 0; k < n; k++)
            {
                if (a[k][i] != a[k][j])
                {
                    flag = false;
                    break;
                }
            }
            if (flag)
                return false;
        }
    }
    return true;
}
bool checkr(int r)
{
    for (int k = 0; k <= r - 2; k++)
    {
        for (int i = 0; i < n; i++)
            if (a[k][i] == a[k + 1][i] && a[k][i] == a[k + 2][i])
                return false;
    }
    for (int i = 0; i < r; i++)
    {
        if (strcmp(a[i], a[r]) == 0)
            return false;
    }
    for (int j = 0; j < n - 2; j++)
    {
        if (a[r][j + 1] == a[r][j + 2] && a[r][j] == a[r][j + 1])
            return false;
    }
    return true;
}
bool dfs(coord coo)
{
    // 递归出口
    if (coo.x == n && coo.y == 0)
    {
        return checkr(coo.x-1) && checkc();
    }
    // 完成一行，进行行查重
    if (coo.y == 0 && coo.x > 0)
    {
        if (!checkr(coo.x - 1))
            return false;
    }
    // 该位置已固定
    if (a[coo.x][coo.y] != '_')
    {
        return dfs(coo.move(n));
    }
    if (r[coo.x][0]>0 && c[coo.y][0]>0)
    {
        char bak = a[coo.x][coo.y];
        a[coo.x][coo.y] = '0';
        r[coo.x][0]--;
        c[coo.y][0]--;
        if (dfs(coo.move(n)))
            return true;
        r[coo.x][0]++;
        c[coo.y][0]++;
        a[coo.x][coo.y] = bak;
    }
    if (r[coo.x][1]>0 && c[coo.y][1]>0)
    {
        char bak = a[coo.x][coo.y];
        a[coo.x][coo.y] = '1';
        r[coo.x][1]--;
        c[coo.y][1]--;
        if (dfs(coo.move(n)))
            return true;
        r[coo.x][1]++;
        c[coo.y][1]++;
        a[coo.x][coo.y] = bak;
    }
    return false;
}
int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
        r[i][0] = r[i][1] = c[i][0] = c[i][1] = n / 2;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
        {
            cin >> a[i][j];
            if (a[i][j] == '0')
            {
                r[i][0]--;
                c[j][0]--;
            }
            if (a[i][j] == '1')
            {
                r[i][1]--;
                c[j][1]--;
            }
        }
    dfs({0, 0});
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
            putchar(a[i][j]);
        putchar('\n');
    }
    return 0;
}