数学 on 安洛的小窝

[leetcode]下一个排列

Fri, 21 Mar 2025 14:49:55 +0800

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

在 leetcode 上看到一道题下一个排列，很明显就是 C++ 中的 std::next_permutation。借此机会研究一下 C++ 中 std::next_permutation 的实现。

示例代码

template<class BidirIt>
bool next_permutation(BidirIt first, BidirIt last)
{
    auto r_first = std::make_reverse_iterator(last);
    auto r_last = std::make_reverse_iterator(first);
    auto left = std::is_sorted_until(r_first, r_last);
 
    if (left != r_last)
    {
        auto right = std::upper_bound(r_first, left, *left);
        std::iter_swap(left, right);
    }
 
    std::reverse(left.base(), last);
    return left != r_last;
}

算法解释

一般求排列，大多数都是求全排列，时间复杂度和空间复杂度都是 O(n!)。此时只需要枚举每个位上的数字即可。但是，对于求下一个排列，这样做效率太低了。std::next_permutation 可以做到在 O(n) 的时间复杂度下原地操作求出下一个排列。该算法乍看不好理解，实际上很像求一个二进制数+1 的算法。下面解释为什么。

首先看 auto left = std::is_sorted_until(r_first, r_last); 这一句。这一句是求从后往前的最长不下降序列。也就是说，求 left，使得区间 $(left, last)$ 内的元素是降序的。为什么要求这个呢？我们从两点来思考。首先，要求字典序上的“下一个”，必然是从后往前更改的。其次，对于一个排列，如果它是降序的，那么它就是字典序上最大的排列了。这就有点像求 $10101111$，首先要找到最后的 $1111$。$1111$ 就是 4 位数里面最大的了，如果再 +1，就务必要进位，那么在整个 +1 的过程中，就只有最后的 5 位 $01111$ 会发生变化，前面的 $101$ 我们就可以不管了。放在求下一个排列也是一样的道理，在求下一个排列的过程中，只有区间 $[left, last)$ 内的数可能发生变化，left 前面的数是不用管的。

那么 $[left, last)$ 内的数要怎么变化呢？$01111+1=10000$，从这个式子我们可以看出，求 $01111+1$ 实际上就是把最前面 $0+1$，然后把后面的 $1111$ 变成最小的，在二进制里面就是 $0000$。那么在求下一个排列里面的？就是在 $(left, right)$ 中找到最小的比 *left 大的数，把 *left和它交换，这个有点像求 $0+1$。在上面的示例代码中就是 if (left != r_last) 这一段的操作。然后需要把后面的 $(left, right)$ 变成最小的，升序排列就是最小的，因此这里可以用 std::sort(left.base(), last);。读者可以试试用 std::sort(left.base(), last) 代替 std::reverse(left.base(), last)，最终结果应该也是对的。那为什么这里用了 std::reverse(left.base(), last) 呢？注意到我们前面提到 $(left, last)$ 内的元素是降序的，刚刚的交换也不会破坏这个有序性，因此在交换完之后 $(left, last)$ 依然是降序排列的。那么就不需要用 std::sort() 了，直接用 std::reverse() 将降序的序列翻转一下就可以变成升序了。

[蓝桥杯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;
    }
}

幂的计算方法

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;
}