跳转至

# 多项式初等函数

本页面包含多项式常见的初等函数操作．具体而言，本页面包含如下内容：

1. 多项式求逆
2. 多项式开方
3. 多项式除法
4. 多项式取模
5. 多项式指数函数
6. 多项式对数函数
7. 多项式三角函数
8. 多项式反三角函数

初等函数与非初等函数

初等函数的定义如下1：

若域 𝐹 F 中存在映射 𝑢 →𝜕𝑢 u→∂u 满足：

1. 𝜕(𝑢 +𝑣) =𝜕𝑢 +𝜕𝑣∂(u+v)=∂u+∂v
2. 𝜕(𝑢 𝑣) =𝑢𝜕𝑣 +𝑣𝜕𝑢∂(u v)=u∂v+v∂u

则称这个域为 微分域．

若微分域 𝐹 F 上的函数 𝑢 u 满足以下的任意一条条件，则称该函数 𝑢 u 为初等函数：

1. 𝑢 u 是 𝐹 F 上的代数函数．
2. 𝑢 u 是 𝐹 F 上的指数性函数，即存在 𝑎 ∈𝐹 a∈F 使得 𝜕𝑢 =𝑢𝜕𝑎∂u=u∂a.
3. 𝑢 u 是 𝐹 F 上的对数性函数，即存在 𝑎 ∈𝐹 a∈F 使得 𝜕𝑢 =𝜕𝑎 𝑎∂u=∂a a.

以下是常见的初等函数：

1. 代数函数：存在有限次多项式 𝑃 P 使得 𝑃(𝑓(𝑥)) =0 P(f(x))=0 的函数 𝑓(𝑥)f(x)，如 2 𝑥 +1 2 x+1,√𝑥 x,(1 +𝑥 2)−1(1+x 2)−1,|𝑥||x|.
2. 指数函数
3. 对数函数
4. 三角函数
5. 反三角函数
6. 双曲函数
7. 反双曲函数

8. 以上函数的复合，如：

   e t a n⁡𝑥 1+𝑥 2 s i n⁡(√1+l n 2⁡𝑥)e tan⁡x 1+x 2 sin⁡(1+ln 2⁡x) −i l n⁡(𝑥+i√1−𝑥 2)−i ln⁡(x+i 1−x 2)

以下是常见的非初等函数：

1. 误差函数：

   e r f⁡(𝑥):=2√𝜋∫𝑥 0 e x p⁡(−𝑡 2)d 𝑡 erf⁡(x):=2 π∫0 x exp⁡(−t 2)d t

## 多项式求逆

给定多项式 𝑓(𝑥)f(x)，求 𝑓−1(𝑥)f−1(x)．

### 解法

#### 倍增法

首先，易知

[𝑥 0]𝑓−1(𝑥)=([𝑥 0]𝑓(𝑥))−1[x 0]f−1(x)=([x 0]f(x))−1

假设现在已经求出了 𝑓(𝑥)f(x) 在模 𝑥⌈𝑛 2⌉x⌈n 2⌉ 意义下的逆元 𝑓−1 0(𝑥)f 0−1(x)． 有：

𝑓(𝑥)𝑓−1 0(𝑥)≡1(m o d 𝑥⌈𝑛 2⌉)𝑓(𝑥)𝑓−1(𝑥)≡1(m o d 𝑥⌈𝑛 2⌉)𝑓−1(𝑥)−𝑓−1 0(𝑥)≡0(m o d 𝑥⌈𝑛 2⌉)f(x)f 0−1(x)≡1(mod x⌈n 2⌉)f(x)f−1(x)≡1(mod x⌈n 2⌉)f−1(x)−f 0−1(x)≡0(mod x⌈n 2⌉)

两边平方可得：

𝑓−2(𝑥)−2 𝑓−1(𝑥)𝑓−1 0(𝑥)+𝑓−2 0(𝑥)≡0(m o d 𝑥 𝑛)f−2(x)−2 f−1(x)f 0−1(x)+f 0−2(x)≡0(mod x n)

两边同乘 𝑓(𝑥)f(x) 并移项可得：

𝑓−1(𝑥)≡𝑓−1 0(𝑥)(2−𝑓(𝑥)𝑓−1 0(𝑥))(m o d 𝑥 𝑛)f−1(x)≡f 0−1(x)(2−f(x)f 0−1(x))(mod x n)

递归计算即可．

时间复杂度

𝑇(𝑛)=𝑇(𝑛 2)+𝑂(𝑛 l o g⁡𝑛)=𝑂(𝑛 l o g⁡𝑛)T(n)=T(n 2)+O(n log⁡n)=O(n log⁡n)

#### Newton's Method

参见 Newton's Method.

#### Graeffe 法

欲求 𝑓−1(𝑥)m o d 𝑥 2 𝑛 f−1(x)mod x 2 n 考虑

𝑓−1(𝑥)m o d 𝑥 2 𝑛=𝑓(−𝑥)(𝑓(𝑥)𝑓(−𝑥))−1 m o d 𝑥 2 𝑛=𝑓(−𝑥)𝑔−1(𝑥 2)m o d 𝑥 2 𝑛 f−1(x)mod x 2 n=f(−x)(f(x)f(−x))−1 mod x 2 n=f(−x)g−1(x 2)mod x 2 n

只需求出 𝑔−1(𝑥)m o d 𝑥 𝑛 g−1(x)mod x n 即可还原出 𝑔−1(𝑥 2)m o d 𝑥 2 𝑛 g−1(x 2)mod x 2 n 因为 𝑓(𝑥)𝑓( −𝑥)f(x)f(−x) 是偶函数，时间复杂度同上．

### 代码

多项式求逆

     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
    constexpr int MAXN = 262144;
    constexpr int mod = 998244353;

    using i64 = long long;
    using poly_t = int[MAXN];
    using poly = int *const;

    void polyinv(const poly &h, const int n, poly &f) {
      /* f = 1 / h = f_0 (2 - f_0 h) */
      static poly_t inv_t;
      std::fill(f, f + n + n, 0);
      f[0] = fpow(h[0], mod - 2);
      for (int t = 2; t <= n; t <<= 1) {
        const int t2 = t << 1;
        std::copy(h, h + t, inv_t);
        std::fill(inv_t + t, inv_t + t2, 0);

        DFT(f, t2);
        DFT(inv_t, t2);
        for (int i = 0; i != t2; ++i)
          f[i] = (i64)f[i] * sub(2, (i64)f[i] * inv_t[i] % mod) % mod;
        IDFT(f, t2);

        std::fill(f + t, f + t2, 0);
      }
    }

### 例题

1. 有标号简单无向连通图计数：「POJ 1737」Connected Graph

## 多项式开方

给定多项式 𝑔(𝑥)g(x)，求 𝑓(𝑥)f(x)，满足：

𝑓 2(𝑥)≡𝑔(𝑥)(m o d 𝑥 𝑛)f 2(x)≡g(x)(mod x n)

### 解法

#### 倍增法

首先讨论 [𝑥 0]𝑔(𝑥)[x 0]g(x) 不为 0 0 的情况．

易知：

[𝑥 0]𝑓(𝑥)=√[𝑥 0]𝑔(𝑥)[x 0]f(x)=[x 0]g(x)

若 [𝑥 0]𝑔(𝑥)[x 0]g(x) 没有平方根，则多项式 𝑔(𝑥)g(x) 没有平方根．

> [𝑥 0]𝑔(𝑥)[x 0]g(x) 可能有多个平方根，选取不同的根会求出不同的 𝑓(𝑥)f(x)．

假设现在已经求出了 𝑔(𝑥)g(x) 在模 𝑥⌈𝑛 2⌉x⌈n 2⌉ 意义下的平方根 𝑓 0(𝑥)f 0(x)，则有：

𝑓 2 0(𝑥)≡𝑔(𝑥)(m o d 𝑥⌈𝑛 2⌉)𝑓 2 0(𝑥)−𝑔(𝑥)≡0(m o d 𝑥⌈𝑛 2⌉)(𝑓 2 0(𝑥)−𝑔(𝑥))2≡0(m o d 𝑥 𝑛)(𝑓 2 0(𝑥)+𝑔(𝑥))2≡4 𝑓 2 0(𝑥)𝑔(𝑥)(m o d 𝑥 𝑛)(𝑓 2 0(𝑥)+𝑔(𝑥)2 𝑓 0(𝑥))2≡𝑔(𝑥)(m o d 𝑥 𝑛)𝑓 2 0(𝑥)+𝑔(𝑥)2 𝑓 0(𝑥)≡𝑓(𝑥)(m o d 𝑥 𝑛)2−1 𝑓 0(𝑥)+2−1 𝑓−1 0(𝑥)𝑔(𝑥)≡𝑓(𝑥)(m o d 𝑥 𝑛)f 0 2(x)≡g(x)(mod x⌈n 2⌉)f 0 2(x)−g(x)≡0(mod x⌈n 2⌉)(f 0 2(x)−g(x))2≡0(mod x n)(f 0 2(x)+g(x))2≡4 f 0 2(x)g(x)(mod x n)(f 0 2(x)+g(x)2 f 0(x))2≡g(x)(mod x n)f 0 2(x)+g(x)2 f 0(x)≡f(x)(mod x n)2−1 f 0(x)+2−1 f 0−1(x)g(x)≡f(x)(mod x n)

倍增计算即可．

时间复杂度

𝑇(𝑛)=𝑇(𝑛 2)+𝑂(𝑛 l o g⁡𝑛)=𝑂(𝑛 l o g⁡𝑛)T(n)=T(n 2)+O(n log⁡n)=O(n log⁡n)

还有一种常数较小的写法就是在倍增维护 𝑓(𝑥)f(x) 的时候同时维护 𝑓−1(𝑥)f−1(x) 而不是每次都求逆．

> 当 [𝑥 0]𝑔(𝑥) ≠1[x 0]g(x)≠1 时，可能需要使用二次剩余来计算 [𝑥 0]𝑓(𝑥)[x 0]f(x)．

上述方法需要知道 𝑓 0(𝑥)f 0(x) 的逆，所以常数项不能为 0 0．

若 [𝑥 0]𝑔(𝑥) =0[x 0]g(x)=0，则将 𝑔(𝑥)g(x) 分解成 𝑥 𝑘 ℎ(𝑥)x k h(x)，其中 [𝑥 0]ℎ(𝑥) ≠0[x 0]h(x)≠0．

- 若 𝑘 k 是奇数，则 𝑔(𝑥)g(x) 没有平方根．

- 若 𝑘 k 是偶数，则求出 ℎ(𝑥)h(x) 的平方根 √ℎ(𝑥)h(x)，然后得到 𝑓(𝑥) ≡𝑥 𝑘/2√ℎ(𝑥)(m o d 𝑥 𝑛)f(x)≡x k/2 h(x)(mod x n)．

洛谷模板题 P5205【模板】多项式开根 参考代码

      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
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    #include <algorithm>
    #include <iostream>
    using namespace std;

    constexpr int MAXN = 1 << 20, mod = 998244353;

    int a[MAXN], b[MAXN], g[MAXN], gg[MAXN];

    int qpow(int x, int y) {  // 快速幂
      int ans = 1;

      while (y) {
        if (y & 1) {
          ans = (long long)1 * ans * x % mod;
        }
        x = (long long)1 * x * x % mod;
        y >>= 1;
      }
      return ans;
    }

    int inv2 = qpow(2, mod - 2);  // 逆元

    void change(int *f, int len) {
      for (int i = 1, j = len / 2; i < len - 1; i++) {
        if (i < j) {
          swap(f[i], f[j]);
        }

        int k = len / 2;
        while (j >= k) {
          j -= k;
          k /= 2;
        }
        if (j < k) {
          j += k;
        }
      }
    }

    void NTT(int *f, int len, int type) {  // NTT
      change(f, len);

      for (int q = 2; q <= len; q <<= 1) {
        int nxt = qpow(3, (mod - 1) / q);
        for (int i = 0; i < len; i += q) {
          int w = 1;

          for (int k = i; k < i + (q >> 1); k++) {
            int x = f[k];
            int y = (long long)1 * w * f[k + (q / 2)] % mod;

            f[k] = (x + y) % mod;
            f[k + (q / 2)] = (x - y + mod) % mod;
            w = (long long)1 * w * nxt % mod;
          }
        }
      }

      if (type == -1) {
        reverse(f + 1, f + len);
        int iv = qpow(len, mod - 2);

        for (int i = 0; i < len; i++) {
          f[i] = (long long)1 * f[i] * iv % mod;
        }
      }
    }

    void inv(int deg, int *f, int *h) {  // 求逆元
      if (deg == 1) {
        h[0] = qpow(f[0], mod - 2);
        return;
      }

      inv((deg + 1) >> 1, f, h);

      int len = 1;
      while (len < deg * 2) {  // 倍增
        len *= 2;
      }

      copy(f, f + deg, gg);
      fill(gg + deg, gg + len, 0);

      NTT(gg, len, 1);
      NTT(h, len, 1);
      for (int i = 0; i < len; i++) {
        h[i] = (long long)1 * (2 - (long long)1 * gg[i] * h[i] % mod + mod) % mod *
               h[i] % mod;
      }

      NTT(h, len, -1);
      fill(h + deg, h + len, 0);
    }

    int n, t[MAXN];

    // deg:次数
    // f:被开根数组
    // h:答案数组
    void sqrt(int deg, int *f, int *h) {
      if (deg == 1) {
        h[0] = 1;
        return;
      }

      sqrt((deg + 1) >> 1, f, h);

      int len = 1;
      while (len < deg * 2) {  // 倍增
        len *= 2;
      }
      fill(g, g + len, 0);
      inv(deg, h, g);
      copy(f, f + deg, t);
      fill(t + deg, t + len, 0);
      NTT(t, len, 1);
      NTT(g, len, 1);
      NTT(h, len, 1);

      for (int i = 0; i < len; i++) {
        h[i] = (long long)1 * inv2 *
               ((long long)1 * h[i] % mod + (long long)1 * g[i] * t[i] % mod) % mod;
      }
      NTT(h, len, -1);
      fill(h + deg, h + len, 0);
    }

    int main() {
      cin >> n;

      for (int i = 0; i < n; i++) {
        cin >> a[i];
      }
      sqrt(n, a, b);

      for (int i = 0; i < n; i++) {
        cout << b[i] << ' ';
      }

      return 0;
    }

#### Newton's Method

参见 Newton's Method.

### 例题

1. 「Codeforces Round #250」E. The Child and Binary Tree

## 多项式除法 & 取模

给定多项式 𝑓(𝑥),𝑔(𝑥)f(x),g(x)，求 𝑔(𝑥)g(x) 除 𝑓(𝑥)f(x) 的商 𝑄(𝑥)Q(x) 和余数 𝑅(𝑥)R(x)．

### 解法

发现若能消除 𝑅(𝑥)R(x) 的影响则可直接 多项式求逆 解决．

考虑构造变换

𝑓 𝑅(𝑥)=𝑥 d e g⁡𝑓 𝑓(1 𝑥)f R(x)=x deg⁡f f(1 x)

观察可知其实质为反转 𝑓(𝑥)f(x) 的系数．

设 𝑛 =d e g⁡𝑓,𝑚 =d e g⁡𝑔 n=deg⁡f,m=deg⁡g．

将 𝑓(𝑥) =𝑄(𝑥)𝑔(𝑥) +𝑅(𝑥)f(x)=Q(x)g(x)+R(x) 中的 𝑥 x 替换成 1 𝑥 1 x 并将其两边都乘上 𝑥 𝑛 x n，得到：

𝑥 𝑛 𝑓(1 𝑥)=𝑥 𝑛−𝑚 𝑄(1 𝑥)𝑥 𝑚 𝑔(1 𝑥)+𝑥 𝑛−𝑚+1 𝑥 𝑚−1 𝑅(1 𝑥)𝑓 𝑅(𝑥)=𝑄 𝑅(𝑥)𝑔 𝑅(𝑥)+𝑥 𝑛−𝑚+1 𝑅 𝑅(𝑥)x n f(1 x)=x n−m Q(1 x)x m g(1 x)+x n−m+1 x m−1 R(1 x)f R(x)=Q R(x)g R(x)+x n−m+1 R R(x)

注意到上式中 𝑅 𝑅(𝑥)R R(x) 的系数为 𝑥 𝑛−𝑚+1 x n−m+1，则将其放到模 𝑥 𝑛−𝑚+1 x n−m+1 意义下即可消除 𝑅 𝑅(𝑥)R R(x) 带来的影响．

又因 𝑄 𝑅(𝑥)Q R(x) 的次数为 (𝑛−𝑚) <(𝑛−𝑚+1)(n−m)<(n−m+1)，故 𝑄 𝑅(𝑥)Q R(x) 不会受到影响．

则：

𝑓 𝑅(𝑥)≡𝑄 𝑅(𝑥)𝑔 𝑅(𝑥)(m o d 𝑥 𝑛−𝑚+1)f R(x)≡Q R(x)g R(x)(mod x n−m+1)

使用多项式求逆即可求出 𝑄(𝑥)Q(x)，将其反代即可得到 𝑅(𝑥)R(x)．

时间复杂度 𝑂(𝑛 l o g⁡𝑛)O(n log⁡n)．

## 多项式对数函数 & 指数函数

给定多项式 𝑓(𝑥)f(x)，求模 𝑥 𝑛 x n 意义下的 l n⁡𝑓(𝑥)ln⁡f(x) 与 e x p⁡𝑓(𝑥)exp⁡f(x)．

### 解法

#### 普通方法

多项式对数函数多项式指数函数

首先，对于多项式 𝑓(𝑥)f(x)，若 l n⁡𝑓(𝑥)ln⁡f(x) 存在，则由其 定义，其必须满足：

[𝑥 0]𝑓(𝑥)=1[x 0]f(x)=1

对 l n⁡𝑓(𝑥)ln⁡f(x) 求导再积分，可得：

d l n⁡𝑓(𝑥)d 𝑥≡𝑓′(𝑥)𝑓(𝑥)(m o d 𝑥 𝑛)l n⁡𝑓(𝑥)≡∫d l n⁡𝑓(𝑥)≡∫𝑓′(𝑥)𝑓(𝑥)d 𝑥(m o d 𝑥 𝑛)d ln⁡f(x)d x≡f′(x)f(x)(mod x n)ln⁡f(x)≡∫d ln⁡f(x)≡∫f′(x)f(x)d x(mod x n)

多项式的求导，积分时间复杂度为 𝑂(𝑛)O(n)，求逆时间复杂度为 𝑂(𝑛 l o g⁡𝑛)O(n log⁡n)，故多项式求 l n ln 时间复杂度 𝑂(𝑛 l o g⁡𝑛)O(n log⁡n)．

首先，对于多项式 𝑓(𝑥)f(x)，若 e x p⁡𝑓(𝑥)exp⁡f(x) 存在，则其必须满足：

[𝑥 0]𝑓(𝑥)=0[x 0]f(x)=0

否则 e x p⁡𝑓(𝑥)exp⁡f(x) 的常数项不收敛．

对 e x p⁡𝑓(𝑥)exp⁡f(x) 求导，可得：

d e x p⁡𝑓(𝑥)d 𝑥≡e x p⁡𝑓(𝑥)𝑓′(𝑥)(m o d 𝑥 𝑛)d exp⁡f(x)d x≡exp⁡f(x)f′(x)(mod x n)

比较两边系数可得：

[𝑥 𝑛−1]d e x p⁡𝑓(𝑥)d 𝑥=𝑛−1∑𝑖=0([𝑥 𝑖]e x p⁡𝑓(𝑥))([𝑥 𝑛−𝑖−1]𝑓′(𝑥))[x n−1]d exp⁡f(x)d x=∑i=0 n−1([x i]exp⁡f(x))([x n−i−1]f′(x))𝑛[𝑥 𝑛]e x p⁡𝑓(𝑥)=𝑛−1∑𝑖=0([𝑥 𝑖]e x p⁡𝑓(𝑥))((𝑛−𝑖)[𝑥 𝑛−𝑖]𝑓(𝑥))n[x n]exp⁡f(x)=∑i=0 n−1([x i]exp⁡f(x))((n−i)[x n−i]f(x))

使用分治 FFT 即可解决．

时间复杂度 𝑂(𝑛 l o g 2⁡𝑛)O(n log 2⁡n)．

#### Newton's Method

使用 Newton's Method 即可在 𝑂(𝑛 l o g⁡𝑛)O(n log⁡n) 的时间复杂度内解决多项式 e x p exp．

### 代码

多项式 ln/exp

     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
    constexpr int MAXN = 262144;
    constexpr int mod = 998244353;

    using i64 = long long;
    using poly_t = int[MAXN];
    using poly = int *const;

    void derivative(const poly &h, const int n, poly &f) {
      for (int i = 1; i != n; ++i) f[i - 1] = (i64)h[i] * i % mod;
      f[n - 1] = 0;
    }

    void integrate(const poly &h, const int n, poly &f) {
      for (int i = n - 1; i; --i) f[i] = (i64)h[i - 1] * inv[i] % mod;
      f[0] = 0; /* C */
    }

    void polyln(const poly &h, const int n, poly &f) {
      /* f = ln h = ∫ h' / h dx */
      assert(h[0] == 1);
      static poly_t ln_t;
      const int t = n << 1;

      derivative(h, n, ln_t);
      std::fill(ln_t + n, ln_t + t, 0);
      polyinv(h, n, f);

      DFT(ln_t, t);
      DFT(f, t);
      for (int i = 0; i != t; ++i) ln_t[i] = (i64)ln_t[i] * f[i] % mod;
      IDFT(ln_t, t);

      integrate(ln_t, n, f);
    }

    void polyexp(const poly &h, const int n, poly &f) {
      /* f = exp(h) = f_0 (1 - ln f_0 + h) */
      assert(h[0] == 0);
      static poly_t exp_t;
      std::fill(f, f + n + n, 0);
      f[0] = 1;
      for (int t = 2; t <= n; t <<= 1) {
        const int t2 = t << 1;

        polyln(f, t, exp_t);
        exp_t[0] = sub(pls(h[0], 1), exp_t[0]);
        for (int i = 1; i != t; ++i) exp_t[i] = sub(h[i], exp_t[i]);
        std::fill(exp_t + t, exp_t + t2, 0);

        DFT(f, t2);
        DFT(exp_t, t2);
        for (int i = 0; i != t2; ++i) f[i] = (i64)f[i] * exp_t[i] % mod;
        IDFT(f, t2);

        std::fill(f + t, f + t2, 0);
      }
    }

### 例题

1. 计算 𝑓 𝑘(𝑥)f k(x)

   普通做法为多项式快速幂，时间复杂度 𝑂(𝑛 l o g⁡𝑛 l o g⁡𝑘)O(n log⁡n log⁡k)．

   当 [𝑥 0]𝑓(𝑥) =1[x 0]f(x)=1 时，有：

   𝑓 𝑘(𝑥)=e x p⁡(𝑘 l n⁡𝑓(𝑥))f k(x)=exp⁡(k ln⁡f(x))

   当 [𝑥 0]𝑓(𝑥) ≠1[x 0]f(x)≠1 时，设 𝑓(𝑥)f(x) 的最低次项为 𝑓 𝑖 𝑥 𝑖 f i x i，则：

   𝑓 𝑘(𝑥)=𝑓 𝑘 𝑖 𝑥 𝑖 𝑘 e x p⁡(𝑘 l n⁡𝑓(𝑥)𝑓 𝑖 𝑥 𝑖)f k(x)=f i k x i k exp⁡(k ln⁡f(x)f i x i)

   时间复杂度 𝑂(𝑛 l o g⁡𝑛)O(n log⁡n)．

## 多项式三角函数

给定多项式 𝑓(𝑥)f(x)，求模 𝑥 𝑛 x n 意义下的 s i n⁡𝑓(𝑥),c o s⁡𝑓(𝑥)sin⁡f(x),cos⁡f(x) 与 t a n⁡𝑓(𝑥)tan⁡f(x)．

### 解法

首先由 Euler's formula (e i 𝑥=c o s⁡𝑥+i s i n⁡𝑥)(e i x=cos⁡x+i sin⁡x) 可以得到 三角函数的另一个表达式：

s i n⁡𝑥=e i 𝑥−e−i 𝑥 2 i c o s⁡𝑥=e i 𝑥+e−i 𝑥 2 sin⁡x=e i x−e−i x 2 i cos⁡x=e i x+e−i x 2

那么代入 𝑓(𝑥)f(x) 就有：

s i n⁡𝑓(𝑥)=e x p⁡(i 𝑓(𝑥))−e x p⁡(−i 𝑓(𝑥))2 i c o s⁡𝑓(𝑥)=e x p⁡(i 𝑓(𝑥))+e x p⁡(−i 𝑓(𝑥))2 sin⁡f(x)=exp⁡(i f(x))−exp⁡(−i f(x))2 i cos⁡f(x)=exp⁡(i f(x))+exp⁡(−i f(x))2

直接按上述表达式编写程序即可得到模 𝑥 𝑛 x n 意义下的 s i n⁡𝑓(𝑥)sin⁡f(x) 与 c o s⁡𝑓(𝑥)cos⁡f(x)．再由 t a n⁡𝑓(𝑥) =s i n⁡𝑓(𝑥)c o s⁡𝑓(𝑥)tan⁡f(x)=sin⁡f(x)cos⁡f(x) 可求得 t a n⁡𝑓(𝑥)tan⁡f(x)．

### 代码

多项式三角函数

注意到我们是在 ℤ 9 9 8 2 4 4 3 5 3 Z 998244353 上做 NTT，那么相应地，虚数单位 i i 应该被换成 8 6 5 8 3 7 1 8 86583718 或 9 1 1 6 6 0 6 3 5 911660635：

i=√−1≡√9 9 8 2 4 4 3 5 2(m o d 9 9 8 2 4 4 3 5 3)⟹o r i≡8 6 5 8 3 7 1 8(m o d 9 9 8 2 4 4 3 5 3)o r i≡9 1 1 6 6 0 6 3 5(m o d 9 9 8 2 4 4 3 5 3)i=−1≡998244352(mod 998244353)⟹or i≡86583718(mod 998244353)or i≡911660635(mod 998244353)

     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
    constexpr int MAXN = 262144;
    constexpr int mod = 998244353;
    constexpr int imgunit = 86583718; /* sqrt(-1) = sqrt(998233452) */

    using i64 = long long;
    using poly_t = int[MAXN];
    using poly = int *const;

    void polytri(const poly &h, const int n, poly &sin_t, poly &cos_t) {
      /* sin(f) = (exp(i * f) - exp(- i * f)) / 2i */
      /* cos(f) = (exp(i * f) + exp(- i * f)) / 2 */
      /* tan(f) = sin(f) / cos(f) */
      assert(h[0] == 0);
      static poly_t tri1_t, tri2_t;

      for (int i = 0; i != n; ++i) tri2_t[i] = (i64)h[i] * imgunit % mod;
      polyexp(tri2_t, n, tri1_t);
      polyinv(tri1_t, n, tri2_t);

      if (sin_t != nullptr) {
        const int invi = fpow(pls(imgunit, imgunit), mod - 2);
        for (int i = 0; i != n; ++i)
          sin_t[i] = (i64)(tri1_t[i] - tri2_t[i] + mod) * invi % mod;
      }
      if (cos_t != nullptr) {
        for (int i = 0; i != n; ++i) cos_t[i] = div2(pls(tri1_t[i], tri2_t[i]));
      }
    }

## 多项式反三角函数

给定多项式 𝑓(𝑥)f(x)，求模 𝑥 𝑛 x n 意义下的 a r c s i n⁡𝑓(𝑥),a r c c o s⁡𝑓(𝑥)arcsin⁡f(x),arccos⁡f(x) 与 a r c t a n⁡𝑓(𝑥)arctan⁡f(x)．

### 解法

仿照求多项式 l n ln 的方法，对反三角函数求导再积分可得：

d d 𝑥 a r c s i n⁡𝑥=1√1−𝑥 2 a r c s i n⁡𝑥=∫1√1−𝑥 2 d 𝑥 d d 𝑥 a r c c o s⁡𝑥=−1√1−𝑥 2 a r c c o s⁡𝑥=−∫1√1−𝑥 2 d 𝑥 d d 𝑥 a r c t a n⁡𝑥=1 1+𝑥 2 a r c t a n⁡𝑥=∫1 1+𝑥 2 d 𝑥 d d x arcsin⁡x=1 1−x 2 arcsin⁡x=∫1 1−x 2 d x d d x arccos⁡x=−1 1−x 2 arccos⁡x=−∫1 1−x 2 d x d d x arctan⁡x=1 1+x 2 arctan⁡x=∫1 1+x 2 d x

那么代入 𝑓(𝑥)f(x) 就有：

d d 𝑥 a r c s i n⁡𝑓(𝑥)=𝑓′(𝑥)√1−𝑓 2(𝑥)a r c s i n⁡𝑓(𝑥)=∫𝑓′(𝑥)√1−𝑓 2(𝑥)d 𝑥 d d 𝑥 a r c c o s⁡𝑓(𝑥)=−𝑓′(𝑥)√1−𝑓 2(𝑥)a r c c o s⁡𝑓(𝑥)=−∫𝑓′(𝑥)√1−𝑓 2(𝑥)d 𝑥 d d 𝑥 a r c t a n⁡𝑓(𝑥)=𝑓′(𝑥)1+𝑓 2(𝑥)a r c t a n⁡𝑓(𝑥)=∫𝑓′(𝑥)1+𝑓 2(𝑥)d 𝑥 d d x arcsin⁡f(x)=f′(x)1−f 2(x)arcsin⁡f(x)=∫f′(x)1−f 2(x)d x d d x arccos⁡f(x)=−f′(x)1−f 2(x)arccos⁡f(x)=−∫f′(x)1−f 2(x)d x d d x arctan⁡f(x)=f′(x)1+f 2(x)arctan⁡f(x)=∫f′(x)1+f 2(x)d x

直接按式子求就可以了．

### 代码

多项式反三角函数

     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
    constexpr int MAXN = 262144;
    constexpr int mod = 998244353;

    using i64 = long long;
    using poly_t = int[MAXN];
    using poly = int *const;

    void derivative(const poly &h, const int n, poly &f) {
      for (int i = 1; i != n; ++i) f[i - 1] = (i64)h[i] * i % mod;
      f[n - 1] = 0;
    }

    void integrate(const poly &h, const int n, poly &f) {
      for (int i = n - 1; i; --i) f[i] = (i64)h[i - 1] * inv[i] % mod;
      f[0] = 0; /* C */
    }

    void polyarcsin(const poly &h, const int n, poly &f) {
      /* arcsin(f) = ∫ f' / sqrt(1 - f^2) dx  */
      static poly_t arcsin_t;
      const int t = n << 1;
      std::copy(h, h + n, arcsin_t);
      std::fill(arcsin_t + n, arcsin_t + t, 0);

      DFT(arcsin_t, t);
      for (int i = 0; i != t; ++i) arcsin_t[i] = sqr(arcsin_t[i]);
      IDFT(arcsin_t, t);

      arcsin_t[0] = sub(1, arcsin_t[0]);
      for (int i = 1; i != n; ++i)
        arcsin_t[i] = arcsin_t[i] ? mod - arcsin_t[i] : 0;

      polysqrt(arcsin_t, n, f);
      polyinv(f, n, arcsin_t);
      derivative(h, n, f);

      DFT(f, t);
      DFT(arcsin_t, t);
      for (int i = 0; i != t; ++i) arcsin_t[i] = (i64)f[i] * arcsin_t[i] % mod;
      IDFT(arcsin_t, t);

      integrate(arcsin_t, n, f);
    }

    void polyarccos(const poly &h, const int n, poly &f) {
      /* arccos(f) = - ∫ f' / sqrt(1 - f^2) dx  */
      polyarcsin(h, n, f);
      for (int i = 0; i != n; ++i) f[i] = f[i] ? mod - f[i] : 0;
    }

    void polyarctan(const poly &h, const int n, poly &f) {
      /* arctan(f) = ∫ f' / (1 + f^2) dx  */
      static poly_t arctan_t;
      const int t = n << 1;
      std::copy(h, h + n, arctan_t);
      std::fill(arctan_t + n, arctan_t + t, 0);

      DFT(arctan_t, t);
      for (int i = 0; i != t; ++i) arctan_t[i] = sqr(arctan_t[i]);
      IDFT(arctan_t, t);

      inc(arctan_t[0], 1);
      std::fill(arctan_t + n, arctan_t + t, 0);

      polyinv(arctan_t, n, f);
      derivative(h, n, arctan_t);

      DFT(f, t);
      DFT(arctan_t, t);
      for (int i = 0; i != t; ++i) arctan_t[i] = (i64)f[i] * arctan_t[i] % mod;
      IDFT(arctan_t, t);

      integrate(arctan_t, n, f);
    }

## 参考资料与链接

1. Elementary function——Wikipedia ↩

> 本页面最近更新：2026/1/7 08:56:54，更新历史
> 发现错误？想一起完善？ 在 GitHub 上编辑此页！
> 本页面贡献者：Tiphereth-A, Marcythm, 97littleleaf11, shuzhouliu, abc1763613206, CCXXXI, EndlessCheng, Enter-tainer, fps5283, Great-designer, H-J-Granger, hly1204, hsfzLZH1, huayucaiji, Ir1d, kenlig, ouuan, SamZhangQingChuan, sshwy, StudyingFather, test12345-pupil, untitledunrevised, c-forrest, ksyx, shawlleyw, TrisolarisHD, TrisolarisHD, xiaoyezi2007, ZnPdCo
> 本页面的全部内容在 CC BY-SA 4.0 和 SATA 协议之条款下提供，附加条款亦可能应用