代码

// author: ycp | https://ycpedef.github.io
// #pragma GCC diagnostic error "-std=c++11"
// #pragma GCC optimize(2)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdarg>
#define debug(x) cerr << #x << " = " << x << endl
#define debugf(...) fprintf(stderr, __VA_ARGS__)
#define wlog(fmt, ...) fprintf(stderr, "<%s:%d> " fmt "\n", __func__, __LINE__, ## __VA_ARGS__)
using namespace std;
template<class T> bool cmax(T &a, T b) { return b > a ? (a = b, 1) : 0; }
template<class T> bool cmin(T &a, T b) { return b < a ? (a = b, 1) : 0; }
template<class T> void read(T &a) {
    a = 0; char c = getchar(); int f = 0;
    while (!isdigit(c)) { f ^= c == '-',  c = getchar(); }
    while (isdigit(c)) { a = a * 10 + (c ^ 48),  c = getchar(); }
    a *= f ? -1 : 1;
}
struct Fastin {
    template<class T> Fastin& operator >> (T &x) { read(x); return *this; }
} fastin;

using u64 = unsigned long long;

const u64 mod = 998244353;
const u64 G = 3;

u64 power(u64 a, int b) {
    u64 res = 1;
    while (b) {
        if (b & 1) (res *= a) %= mod;
        b >>= 1, (a *= a) %= mod;
    }
    return res;
}

struct poly_t {
    int n, cap; // cap is CAPACITY !
    u64 *src; 

    poly_t(int siz) { src = new u64[siz], cap = siz; }
    ~poly_t() { delete[] src; }
    inline u64& operator [] (const int &pos) { return src[pos]; }

    void resize(int c) { delete[] src; src = new u64[c], cap = c; }

    void print() {
        for(int i = 0; i < n; ++i) debugf("src[%d] = %lld\n", i, src[i]);
    }

    void transform() {
        int* rev = new int[cap]();
        for (int i = 0; i < n; i++) {
            rev[i] = (rev[i >> 1] >> 1) | ((i & 1) * (n >> 1));
        }
        for (int i = 0; i < n; i++) {
            if (i < rev[i]) swap(src[i], src[rev[i]]);
        }
        delete[] rev;
    }

    void NTT(int mode) {
        transform();
        u64 *f = src;
        for (int len = 2, k = 1; len <= n; len <<= 1, k <<= 1) {
            u64 g0 = power(G, (mod - 1) / len);
            for (int i = 0; i < n; i += len) {
                u64 g = 1, t1, t2;
                for (int j = i; j < i + k; j++) {
                    t1 = f[j], t2 = (g * f[k + j]) % mod;
                    f[j] = t1 + t2;
                    f[j + k] = t1 - t2 + mod;
                    (g *= g0) %= mod;
                }
            }
            if (len == (1 << 18)) {
                for (int i = 0; i < n; i++) { f[i] %= mod; }
            }
        }
        if (mode < 0) {
            reverse(f + 1, f + n);
            u64 inv = power(n, mod - 2);
            for (int i = 0; i < n; i++) {
                (f[i] *= inv) %= mod;
            }
        } else {
            for (int i = 0; i < n; i++) { f[i] %= mod; }
        }
    }
    void DFT() { return NTT(1); }
    void IDFT() { return NTT(-1); }
};

int n, m;

int main() {
    fastin >> n >> m;
    int len = 1;
    while (len < n + m + 1) {
        len <<= 1;
    }
    poly_t a(len + 10), b(len + 10);
    a.n = len, b.n = len;
    for (int i = 0; i <= n; i++) {
        fastin >> a[i];
    }
    for (int i = 0; i <= m; i++) {
        fastin >> b[i];
    }
    a.DFT();
    b.DFT();
    //a.print(), b.print();
    poly_t c(len + 10);
    c.n = len;
    for (int i = 0; i <= len; i++) {
        (c[i] = a[i] * b[i]) %= mod;
    }
    c.IDFT();
    for (int i = 0; i <= n + m; i++) {
        printf("%llu ", c[i]);
    }
    return 0;
}

评测结果