代码

const int p = 931135487;
#define w(n) pow_modp({14, +424191271i}, (p + 1) / n)
#define v(n) pow_modp({14, -424191271i}, (p + 1) / n)

#include <cstdio>
#include <cctype>
#include <algorithm>
#include <cmath>

namespace fastIO {
    const int SZ = 1 << 25;
    char ibuf[SZ], *p0 = ibuf, *p1 = ibuf;
    inline char getchar(void) { return p0 == p1 && (p1 = (p0 = ibuf) + fread(ibuf, 1, SZ, stdin), p0 == p1) ? EOF : *p0++; }
    char char_read; void read(auto &val) {
		val = 0; do char_read = getchar(); while(!isdigit(char_read));
		do val = val * 10 + char_read - '0'; while(isdigit(char_read = getchar()));
    }
    char obuf[SZ], *p = obuf;
    inline void putchar(char char_write) { *p++ = char_write; }
    void write(auto val) { if(val >= 10) write(val / 10); putchar(val % 10 + '0'); }
    inline void write(auto a[], int sz) { for(int i = 0; i < sz; ++i) write(a[i]), putchar(' '); putchar('\n'); }
    void output(void) { fwrite(obuf, p - obuf, 1, stdout);}
};

const int N = 1 << 21;

int pow_modp(int a, auto b) { int x = 1; for(; b; a = (long long)a * a % p, b >>= 1) if(b & 1) x = (long long)x * a % p; return x; }
struct CMPLX {
	int real, imag;
	CMPLX operator + (const CMPLX z) const { return {real + z.real < 0 ? real + z.real + p : real + z.real - p, imag + z.imag < 0 ? imag + z.imag + p : imag + z.imag - p}; }
	CMPLX operator - (const CMPLX z) const { return {real - z.real < 0 ? real - z.real + p : real - z.real - p, imag - z.imag < 0 ? imag - z.imag + p : imag - z.imag - p}; }
	CMPLX operator * (const CMPLX z) const { return {((long long)real * z.real - (long long)imag * z.imag) % p, ((long long)real * z.imag + (long long)imag * z.real) % p}; }
};
CMPLX pow_modp(CMPLX a, auto b) { CMPLX x = {1, 0}; for(; b; a = a * a, b >>= 1) if(b & 1) x = x * a; return x; }

CMPLX cntt_sup[N];
void cntt(auto a[], int n, CMPLX w) {
	auto cntt_a = cntt_sup; for(int i = 1; i < n; i <<= 1, w = w * w, std :: swap(a, cntt_a)) {
		auto _w = (CMPLX){1, 0}; for(auto k0 = cntt_a, j0 = a, j1 = a + (n >> 1); k0 != cntt_a + n; k0 += i, _w = _w * w)
			for(auto k1 = k0 + i, _k0 = k1; k0 != _k0; ++j0, ++j1, ++k0, ++k1) *k0 = *j0 + *j1,
				k1->real = ((long long)(j0->real - j1->real) * _w.real - (long long)(j0->imag - j1->imag) * _w.imag) % p,
				k1->imag = ((long long)(j0->real - j1->real) * _w.imag + (long long)(j0->imag - j1->imag) * _w.real) % p;
	}
	if(cntt_a != cntt_sup) std :: copy(a, a + n, cntt_a);
}
void poly_mul(auto a[], auto b[], int n) {
	cntt(a, n, w(n)), cntt(b, n, w(n)); for(int i = 0; i < n; ++i) a[i] = a[i] * b[i]; cntt(a, n, v(n));
	CMPLX inv_n = {pow_modp(n, p - 2), 0}; for(int i = 0; i < n; ++i) a[i] = a[i] * inv_n;
}

int n, n_a, n_b;
CMPLX a[N], b[N];
int ans[N];

int main(void) {
	fastIO :: read(n_a), fastIO :: read(n_b); ++n_a, ++n_b; for(n = 1; n < n_a + n_b - 1; n <<= 1);
	for(int i = 0, t; i < n_a; ++i) fastIO :: read(t), a[i].real = t;
	for(int i = 0, t; i < n_b; ++i) fastIO :: read(t), b[i].real = t;
	poly_mul(a, b, n); n = n_a + n_b - 1;
	for(int i = 0; i < n; ++i) ans[i] = a[i].real < 0 ? a[i].real + p : a[i].real;
	fastIO :: write(ans, n), fastIO :: output();
	return 0;
}

评测结果