你说的对，但是量子力学（Quantum Mechanics），为物理学理论，是研究物质世界微观粒子运动规律的物理学分支，主要研究原子、分子、凝聚态物质，以及原子核和基本粒子的结构、性质的基础理论。它与相对论一起构成现代物理学的理论基础。量子力学不仅是现代物理学的基础理论之一，而且在化学等学科和许多近代技术中得到广泛应用。
19世纪末，人们发现旧有的经典理论无法解释微观系统，于是经由物理学家的努力，在20世纪初创立量子力学，解释了这些现象。量子力学从根本上改变人类对物质结构及其相互作用的理解。除了广义相对论描写的引力以外，迄今所有基本相互作用均可以在量子力学的框架内描述（量子场论）。

快速傅里叶变换 (fast Fourier transform), 即利用计算机计算离散傅里叶变换（DFT)的高效、快速计算方法的统称，简称FFT。快速傅里叶变换是1965年由J.W.库利和T.W.图基提出的。采用这种算法能使计算机计算离散傅里叶变换所需要的乘法次数大为减少，特别是被变换的抽样点数N越多，FFT算法计算量的节省就越显著。

递归版fft
#include <cmath> #include <complex> typedef std::complex<double> Comp; // STL complex const Comp I(0, 1); // i const int MAX_N = 1 << 20; Comp tmp[MAX_N]; // rev=1,DFT; rev=-1,IDFT void DFT(Comp* f, int n, int rev) { if (n == 1) return; for (int i = 0; i < n; ++i) tmp[i] = f[i]; // 偶数放左边，奇数放右边 for (int i = 0; i < n; ++i) { if (i & 1) f[n / 2 + i / 2] = tmp[i]; else f[i / 2] = tmp[i]; } Comp *g = f, *h = f + n / 2; // 递归 DFT DFT(g, n / 2, rev), DFT(h, n / 2, rev); // cur 是当前单位复根，对于 k = 0 而言，它对应的单位复根 omega^0_n = 1。 // step 是两个单位复根的差，即满足 omega^k_n = step*omega^{k-1}*n， // 定义等价于 exp(I*(2*M_PI/n*rev)) Comp cur(1, 0), step(cos(2 * M_PI / n), sin(2 * M_PI * rev / n)); for (int k = 0; k < n / 2; ++k) { // F(omega^k_n) = G(omega^k*{n/2}) + omega^k*n\*H(omega^k*{n/2}) tmp[k] = g[k] + cur * h[k]; // F(omega^{k+n/2}*n) = G(omega^k*{n/2}) - omega^k_n*H(omega^k\_{n/2}) tmp[k + n / 2] = g[k] - cur * h[k]; cur *= step; } for (int i = 0; i < n; ++i) f[i] = tmp[i]; }

非递归版fft
/* * 做 FFT * len 必须是 2^k 形式 * on == 1 时是 DFT，on == -1 时是 IDFT */ void fft(Complex y[], int len, int on) { // 位逆序置换 change(y, len); // 模拟合并过程，一开始，从长度为一合并到长度为二，一直合并到长度为 len。 for (int h = 2; h <= len; h <<= 1) { // wn：当前单位复根的间隔：w^1_h Complex wn(cos(2 * PI / h), sin(on * 2 * PI / h)); // 合并，共 len / h 次。 for (int j = 0; j < len; j += h) { // 计算当前单位复根，一开始是 1 = w^0_n，之后是以 wn 为间隔递增： w^1_n // ... Complex w(1, 0); for (int k = j; k < j + h / 2; k++) { // 左侧部分和右侧是子问题的解 Complex u = y[k]; Complex t = w * y[k + h / 2]; // 这就是把两部分分治的结果加起来 y[k] = u + t; y[k + h / 2] = u - t; // 后半个 “step” 中的ω一定和 “前半个” 中的成相反数 // “红圈”上的点转一整圈“转回来”，转半圈正好转成相反数 // 一个数相反数的平方与这个数自身的平方相等 w = w * wn; } } } // 如果是 IDFT，它的逆矩阵的每一个元素不只是原元素取倒数，还要除以长度 len。 if (on == -1) { for (int i = 0; i < len; i++) { y[i].x /= len; } } }

你说的很对，但是我现在每天玩三国杀都能赚100菜篮子，每个月差不多3000菜篮子的收入，也就是现实生活中每个月1500美元的收入水平，换算过来最少也9000人民币，虽然我只有14岁，但是已经超越了中国绝大多数人(包括你)的水平，这便是三国杀给我的骄傲的资本。

数论变换(number-theoretic transform, NTT）是离散傅里叶变换（DFT）在数论基础上的实现；快速数论变换(fast number-theoretic transform, FNTT）是 快速傅里叶变换（FFT）在数论基础上的实现。
数论变换 是一种计算卷积（convolution）的快速算法。最常用算法就包括了前文提到的快速傅里叶变换。然而快速傅立叶变换具有一些实现上的缺点，举例来说，资料向量必须乘上复数系数的矩阵加以处理，而且每个复数系数的实部和虚部是一个正弦及余弦函数，因此大部分的系数都是浮点数，也就是说，必须做复数而且是浮点数的运算，因此计算量会比较大，而且浮点数运算产生的误差会比较大。
NTT 解决的是多项式乘法带模数的情况，可以说有些受模数的限制，数也比较大。目前最常见的模数是 998244353。

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 300100, P = 998244353;
inline int qpow(int x, int y) {
int res(1);
while (y) {
if (y & 1) res = 1ll * res * x % P;
x = 1ll * x * x % P;
y >>= 1;
}
return res;
}
int r[N];
void ntt(int *x, int lim, int opt) {
register int i, j, k, m, gn, g, tmp;
for (i = 0; i < lim; ++i)
if (r[i] < i) swap(x[i], x[r[i]]);
for (m = 2; m <= lim; m <<= 1) {
k = m >> 1;
gn = qpow(3, (P - 1) / m);
for (i = 0; i < lim; i += m) {
g = 1;
for (j = 0; j < k; ++j, g = 1ll * g * gn % P) {
tmp = 1ll * x[i + j + k] * g % P;
x[i + j + k] = (x[i + j] - tmp + P) % P;
x[i + j] = (x[i + j] + tmp) % P;
}
}
}
if (opt == -1) {
reverse(x + 1, x + lim);
register int inv = qpow(lim, P - 2);
for (i = 0; i < lim; ++i) x[i] = 1ll * x[i] * inv % P;
}
}
int A[N], B[N], C[N];
char a[N], b[N];
int main() {
register int i, lim(1), n;
scanf("%s", &a);
n = strlen(a);
for (i = 0; i < n; ++i) A[i] = a[n - i - 1] - '0';
while (lim < (n << 1)) lim <<= 1;
scanf("%s", &b);
n = strlen(b);
for (i = 0; i < n; ++i) B[i] = b[n - i - 1] - '0';
while (lim < (n << 1)) lim <<= 1;
for (i = 0; i < lim; ++i) r[i] = (i & 1) * (lim >> 1) + (r[i >> 1] >> 1);
ntt(A, lim, 1);
ntt(B, lim, 1);
for (i = 0; i < lim; ++i) C[i] = 1ll * A[i] * B[i] % P;
ntt(C, lim, -1);

你说得对，但是《千恋万花》是由柚子社自主研发的一款美少女恋爱游戏。游戏发生在一个被称作“穗织”的小镇，在这里，被神选中的人将被授予“丛雨丸”，导引祓除之力。玩家将扮演一位名为“有地将臣”的角色，在自由的旅行中邂逅性格各异、能力独特的同伴们，和他们一起击败崇神，找回失散的依代——同时，逐步发掘“诅咒”的真相。