多项式——乘法逆元

最新推荐文章于 2022-11-15 12:03:51 发布

爱寂寞的时光

最新推荐文章于 2022-11-15 12:03:51 发布

阅读量1.7k

点赞数 1

分类专栏：算法离散数学 # 组合数学、概率论、博弈论与数理统计等基础数学文章标签：算法 c++

本文链接：https://blog.csdn.net/jiahonghao2002/article/details/126089643

版权

组合数学、概率论、博弈论与数理统计等基础数学同时被 3 个专栏收录

40 篇文章 2 订阅

订阅专栏

离散数学

17 篇文章 2 订阅

订阅专栏

算法

13 篇文章 1 订阅

订阅专栏

多项式——乘法逆元

给定一个多项式 $F (x)$ ，请求出一个多项式 $G (x)$ 满足 $\equiv 1 \mod x^n$ 。系数对 $998244353$ 取模。

P4238 【模板】多项式乘法逆

本文只介绍递推的方法，首先将 $n$ 补齐到 2 的幂次，当 $n = 1$ 的时候，多项式中只有一项，那么 $x^0]G(x)$ 就是 $x^0]F(x)$ 的乘法逆元。

假设我们已知 $\equiv 1 \mod x^{\frac{n}{2}}$ ，那么显然 $\equiv 1 \mod x^{\frac{n}{2}}$ ，那么 $\equiv 0 \mod x^{\frac{n}{2}}$ ，即 $\equiv 0 \mod x^{\frac{n}{2}}$ 。

两边同时平方得到 $G(x)^2 + H(x)^2 -2G(x)H(x) \equiv 0 \mod x^n$ ，这是因为原来是 $x^{\frac{n}{2}}$ 的倍数，平方之后一定也是 $x^n$ 的倍数。

最后，两边同时乘以 $F (x)$ 使得 $G(x)^2$ 项降幂，因为 $\equiv 1 \mod x^n$ 最后得到：

$\equiv 2H(x) - F(x)H(x)^2 \mod x^n$

用 NTT 来加速多项式乘法，时间复杂度为 $\log n)$ 。

#include <bits/stdc++.h>

using namespace std;

using ll = long long;

#ifdef LLT_DBG
#define FR freopen("in.txt", "r", stdin)
#else
#define FR
#endif

template <ll P>
ll fpow(ll a, ll b)
{
    ll res = 1;
    for (; b; b >>= 1, a = (a * a) % P)
        if (b & 1)
            res = (res * a) % P;
    return res;
}

template <ll G, ll P>
struct NTT
{
    int _n;
    int E;
    vector<int> rev;

    /**
     * @brief 构建一个 NTT 计算器
     *
     * @param n 多项式最高项数
     */
    NTT(int n)
    {
        _n = 1;
        E = 0;
        while (_n < n)
        {
            _n <<= 1;
            E++;
        }
        rev.resize(_n);
        // 逆位置对换
        for (int i = 1; i < _n; i++)
        {
            rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (E - 1));
        }
    }

    void _rNTT(ll A[], ll k)
    {
        for (int i = 0; i < _n; i++)
            if (i < rev[i])
                swap(A[i], A[rev[i]]);

        for (int e = 1; e <= E; e++)
        {
            int m = 1 << e;

            for (int i = 0; i < _n; i += m)
            {
                int hf = m / 2;
                ll g = 1;
                ll gn = fpow<P>(fpow<P>(G, (P - 1) / m), k);

                for (int j = 0; j < hf; j++)
                {
                    ll x = A[i + j];
                    ll y = (A[i + j + hf] * g) % P;
                    A[i + j] = (x + y) % P;
                    A[i + j + hf] = (x - y) % P;
                    g = (g * gn) % P;
                }
            }
        }
    }

    /**
     * @brief NTT 过程
     *
     * @param A 系数数组
     */
    void doNTT(ll A[])
    {
        _rNTT(A, 1);
    }

    /**
     * @brief NTT 逆过程
     *
     * @param A 点值数组
     */
    void doINTT(ll A[])
    {
        ll ni = fpow<P>(_n, P - 2);
        _rNTT(A, P - 2);
        for (int i = 0; i < _n; i++)
            A[i] = (A[i] * ni) % P;
    }
};

ll A[500005];
ll F[500005];
ll B[500005];
ll G[500005];

const int mod = 998244353;

void solve()
{
    int n;
    cin >> n;

    for (int i = 0; i < n; i++)
    {
        cin >> A[i];
    }

    //  初始步骤
    G[0] = fpow<mod>(A[0], mod - 2);

    // 归纳步骤
    int i = 1;
    while (i < n)
    {
        i <<= 1;
        for (int j = 0; j < i; j++)
            B[j] = 0;

        // 注意最大界为 2i
        
        for (int j = 0; j < (i >> 1); j++)
            B[j] = G[j];

        for (int j = 0; j < i; j++)
            F[j] = A[j];

        NTT<3, mod> ntt(i << 1);
        ntt.doNTT(F);

        ntt.doNTT(B);

        for (int j = 0; j < (i << 1); j++)
            B[j] = B[j] * B[j] % mod * F[j] % mod;
        ntt.doINTT(B);

        for (int j = 0; j < i; j++)
        {
            G[j] = (2 * G[j] % mod - B[j]) % mod;
            G[j] = (G[j] + mod) % mod;
        }
    }

    for (int i = 0; i < n; i++)
    {
        G[i] = (G[i] + mod) % mod;
        cout << G[i] << " ";
    }
}

int main()
{
    FR;
    solve();
    return 0;
}