Fixes

Author: adamant-pwn

cp-algo/math/fft.hpp

@@ -271,7 +271,9 @@ namespace cp_algo::math::fft {
     }
     void mul_truncate(auto &a, auto const& b, size_t k) {
         using base = std::decay_t<decltype(a[0])>;
-        auto n = std::max(flen, std::bit_ceil(k) / 2);
+        auto n = std::max(flen, std::bit_ceil(
+            std::min(k, size(a)) + std::min(k, size(b)) - 1
+        ) / 2);
         auto A = dft<base>(std::views::take(a, k), n);
         if(size(a) != k) {
             a.resize(k);
@@ -283,12 +285,9 @@ namespace cp_algo::math::fft {
         }
     }
     void mul(auto &a, auto const& b) {
-        if(size(a) || size(b)) {
+        if(size(a)) {
             mul_truncate(a, b, size(a) + size(b) - 1);
         }
     }
-    void circular_mul(auto &a, auto const& b) {
-        mul_truncate(a, b, std::max(size(a), size(b)));
-    }
 }
 #endif // CP_ALGO_MATH_FFT_HPP

cp-algo/math/poly.hpp

@@ -202,19 +202,29 @@ namespace cp_algo::math {
             return poly_t(*this).log_inplace(n);
         }
 
-        poly_t exp(size_t n) const { // calculate exp p(x) mod x^n
+        poly_t& mul_truncate(poly_t const& t, size_t k) {
+            fft::mul_truncate(a, t.a, k);
+            normalize();
+            return *this;
+        }
+
+        poly_t& exp_inplace(size_t n) {
             if(is_zero()) {
-                return T(1);
+                return *this = T(1);
             }
             assert(a[0] == T(0));
-            poly_t ans = T(1);
+            a[0] = 1;
             size_t a = 1;
             while(a < n) {
-                poly_t C = ans.log(2 * a).div_xk(a) - substr(a, 2 * a);
-                ans -= (ans * C).mod_xk(a).mul_xk(a);
+                poly_t C = log(2 * a).div_xk_inplace(a) - substr(a, 2 * a);
+                *this -= C.mul_truncate(*this, a).mul_xk_inplace(a);
                 a *= 2;
             }
-            return ans.mod_xk(n);
+            return mod_xk_inplace(n);
+        }
+
+        poly_t exp(size_t n) const { // calculate exp p(x) mod x^n
+            return poly_t(*this).exp_inplace(n);
         }
 
         poly_t pow_bin(int64_t k, size_t n) const { // O(n log n log k)
@@ -537,13 +547,6 @@ namespace cp_algo::math {
             return a * b.reverse();
         }
 
-        // [x^k] (a semicorr b) = sum_i a{i+k} * b{i}
-        static poly_t inner_semicorr(poly_t const& a, poly_t const& b) {
-            auto ta = a.a;
-            fft::circular_mul(ta, b.reverse().a);
-            return poly_t(ta).div_xk(b.deg());
-        }
-
         // [x^k] (a semicorr b) = sum_i a{i+k} * b{i}
         static poly_t semicorr(poly_t const& a, poly_t const& b) {
             return corr(a, b).div_xk(b.deg());

verify/poly/exp.test.cpp

@@ -0,0 +1,30 @@
+// @brief Exp of Power Series
+#define PROBLEM "https://judge.yosupo.jp/problem/exp_of_formal_power_series"
+#pragma GCC optimize("Ofast,unroll-loops")
+#include "cp-algo/math/poly.hpp"
+#include <bits/stdc++.h>
+
+using namespace std;
+using namespace cp_algo::math;
+
+const int mod = 998244353;
+using base = modint<mod>;
+using polyn = poly_t<base>;
+
+void solve() {
+    int n;
+    cin >> n;
+    vector<base> a(n);
+    copy_n(istream_iterator<base>(cin), n, begin(a));
+    polyn(a).exp_inplace(n).print(n);
+}
+
+signed main() {
+    //freopen("input.txt", "r", stdin);
+    ios::sync_with_stdio(0);
+    cin.tie(0);
+    int t = 1;
+    while(t--) {
+        solve();
+    }
+}