fork download
copy 
  1. #include <iostream>
  2. #include <algorithm>
  3. #include <vector>
  4. #include <complex>
  5. #include <cmath>
  6. #include <random>
  7. #include <cassert>
  8.  
  9. using namespace std;
  10.  
  11. const int mod = 1e9 + 7;
  12.  
  13. struct mint {
  14.   int n;
  15.   mint(int n_ = 0) : n(n_) {}
  16. };
  17.  
  18. mint operator-(mint a) { return a.n == 0 ? 0 : mod - a.n; }
  19. mint operator+(mint a, mint b) { return (a.n += b.n) >= mod ? a.n - mod : a.n; }
  20. mint operator-(mint a, mint b) { return (a.n -= b.n) < 0 ? a.n + mod : a.n; }
  21. mint operator*(mint a, mint b) { return 1LL * a.n * b.n % mod; }
  22. mint &operator+=(mint &a, mint b) { return a = a + b; }
  23. mint &operator-=(mint &a, mint b) { return a = a - b; }
  24. mint &operator*=(mint &a, mint b) { return a = a * b; }
  25. ostream &operator<<(ostream &o, mint a) { return o << a.n; }
  26.  
  27. mint modpow(mint a, long long b) {
  28.   mint res = 1;
  29.   while (b > 0) {
  30.     if (b & 1) res *= a;
  31.     a *= a;
  32.     b >>= 1;
  33.   }
  34.   return res;
  35. }
  36.  
  37. mint modinv(mint a) {
  38.   return modpow(a, mod - 2);
  39. }
  40.  
  41. template<int N>
  42. struct FFT {
  43.   complex<double> rots[N];
  44.  
  45.   FFT() {
  46.     const double pi = acos(-1);
  47.     for (int i = 0; i < N / 2; i++) {
  48.       rots[i + N / 2].real(cos(2 * pi / N * i));
  49.       rots[i + N / 2].imag(sin(2 * pi / N * i));
  50.     }
  51.     for (int i = N / 2 - 1; i >= 1; i--) {
  52.       rots[i] = rots[i * 2];
  53.     }
  54.   }
  55.  
  56.   inline complex<double> mul(complex<double> a, complex<double> b) {
  57.     return complex<double>(
  58.       a.real() * b.real() - a.imag() * b.imag(),
  59.       a.real() * b.imag() + a.imag() * b.real()
  60.     );
  61.   }
  62.  
  63.   void fft(vector<complex<double>> &a, bool rev) {
  64.     const int n = a.size();
  65.     int i = 0;
  66.     for (int j = 1; j < n - 1; j++) {
  67.       for (int k = n >> 1; k > (i ^= k); k >>= 1);
  68.       if (j < i) {
  69.         swap(a[i], a[j]);
  70.       }
  71.     }
  72.     for (int i = 1; i < n; i *= 2) {
  73.       for (int j = 0; j < n; j += i * 2) {
  74.         for (int k = 0; k < i; k++) {
  75.           auto s = a[j + k + 0];
  76.           auto t = mul(a[j + k + i], rots[i + k]);
  77.           a[j + k + 0] = s + t;
  78.           a[j + k + i] = s - t;
  79.         }
  80.       }
  81.     }
  82.     if (rev) {
  83.       reverse(a.begin() + 1, a.end());
  84.       for (int i = 0; i < n; i++) {
  85.         a[i] *= 1.0 / n;
  86.       }
  87.     }
  88.   }
  89.  
  90.   vector<long long> convolution(vector<long long> a, vector<long long> b) {
  91.     int t = 1;
  92.     while (t < a.size() + b.size() - 1) t *= 2;
  93.     vector<complex<double>> z(t);
  94.     for (int i = 0; i < a.size(); i++) z[i].real(a[i]);
  95.     for (int i = 0; i < b.size(); i++) z[i].imag(b[i]);
  96.     fft(z, false);
  97.     vector<complex<double>> w(t);
  98.     for (int i = 0; i < t; i++) {
  99.       auto p = (z[i] + conj(z[(t - i) % t])) * complex<double>(0.5, 0);
  100.       auto q = (z[i] - conj(z[(t - i) % t])) * complex<double>(0, -0.5);
  101.       w[i] = p * q;
  102.     }
  103.     fft(w, true);
  104.     vector<long long> ans(a.size() + b.size() - 1);
  105.     for (int i = 0; i < ans.size(); i++) {
  106.       ans[i] = round(w[i].real());
  107.     }
  108.     return ans;
  109.   }
  110.  
  111.   vector<mint> convolution(vector<mint> a, vector<mint> b) {
  112.     int t = 1;
  113.     while (t < a.size() + b.size() - 1) t *= 2;
  114.     vector<complex<double>> A(t), B(t);
  115.     for (int i = 0; i < a.size(); i++) A[i] = complex<double>(a[i].n & 0x7fff, a[i].n >> 15);
  116.     for (int i = 0; i < b.size(); i++) B[i] = complex<double>(b[i].n & 0x7fff, b[i].n >> 15);
  117.     fft(A, false);
  118.     fft(B, false);
  119.     vector<complex<double>> C(t), D(t);
  120.     for (int i = 0; i < t; i++) {
  121.       int j = (t - i) % t;
  122.       auto AL = (A[i] + conj(A[j])) * complex<double>(0.5, 0);
  123.       auto AH = (A[i] - conj(A[j])) * complex<double>(0, -0.5);
  124.       auto BL = (B[i] + conj(B[j])) * complex<double>(0.5, 0);
  125.       auto BH = (B[i] - conj(B[j])) * complex<double>(0, -0.5);
  126.       C[i] = AL * BL + AH * BL * complex<double>(0, 1);
  127.       D[i] = AL * BH + AH * BH * complex<double>(0, 1);
  128.     }
  129.     fft(C, true);
  130.     fft(D, true);
  131.     vector<mint> ans(a.size() + b.size() - 1);
  132.     for (int i = 0; i < ans.size(); i++) {
  133.       long long l = (long long)round(C[i].real()) % mod;
  134.       long long m = ((long long)round(C[i].imag()) + (long long)round(D[i].real())) % mod;
  135.       long long h = (long long)round(D[i].imag()) % mod;
  136.       ans[i] = (l + (m << 15) + (h << 30)) % mod;
  137.     }
  138.     return ans;
  139.   }
  140. };
  141. FFT<1 << 21> fft;
  142.  
  143. typedef vector<mint> poly; 
  144.  
  145. poly operator-(poly a) {
  146.   for (int i = 0; i < a.size(); i++) {
  147.     a[i] = -a[i];
  148.   }
  149.   return a;
  150. }
  151.  
  152. poly operator+(poly a, poly b) {
  153.   for (int i = 0; i < a.size(); i++) {
  154.     a[i] += b[i];
  155.   }
  156.   return a;
  157. }
  158.  
  159. poly operator-(poly a, poly b) {
  160.   for (int i = 0; i < a.size(); i++) {
  161.     a[i] -= b[i];
  162.   }
  163.   return a;
  164. }
  165.  
  166. poly &operator+=(poly &a, poly b) { return a = a + b; }
  167. poly &operator-=(poly &a, poly b) { return a = a - b; }
  168.  
  169. poly pinv(poly a) {
  170.   const int n = a.size();
  171.   poly x = {modinv(a[0])};
  172.   for (int i = 1; i < n; i *= 2) {
  173.     vector<mint> tmp(min(i * 2, n));
  174.     for (int j = 0; j < tmp.size(); j++) {
  175.       tmp[j] = a[j];
  176.     }
  177.     auto e = -fft.convolution(tmp, x);
  178.     e[0] += 2;
  179.     x = fft.convolution(x, e);
  180.     x.resize(i * 2);
  181.   }
  182.   x.resize(n);
  183.   return x;
  184. }
  185.  
  186. poly plog(poly a) {
  187.   const int n = a.size();
  188.   vector<mint> b(n);
  189.   for (int i = 1; i < n; i++) {
  190.     b[i - 1] = i * a[i];
  191.   }
  192.   a = fft.convolution(pinv(a), b);
  193.   for (int i = n - 1; i >= 1; i--) {
  194.     a[i] = modinv(i) * a[i - 1];
  195.   }
  196.   a[0] = 0;
  197.   a.resize(n);
  198.   return a;
  199. }
  200.  
  201. poly pexp(poly a) {
  202.   const int n = a.size();
  203.   poly x = {1};
  204.   for (int i = 1; i < n; i *= 2) {
  205.     auto e = -plog(x);
  206.     e[0] += 1;
  207.     e.resize(min(i * 2, n));
  208.     for (int j = 0; j < e.size(); j++) {
  209.       e[j] += a[j];
  210.     }
  211.     x = fft.convolution(x, e);
  212.     x.resize(i * 2);
  213.   }
  214.   x.resize(n);
  215.   return x;
  216. }
  217.  
  218.  
  219.  
  220.  
  221. vector<mint> partition(int n) {
  222.   poly a(n);
  223.   for (int i = 1; i < n; i++) {
  224.     for (int j = 1; i * j < n; j++) {
  225.       a[i * j] += modinv(j);
  226.     }
  227.   }
  228.   return pexp(a);
  229. }
  230.  
  231. vector<mint> bell_polynomial(int n) {
  232.   if (n == 0) return {1};
  233.   poly a(n + 1);
  234.   poly b(n + 1);
  235.   a[0] = 1;
  236.   mint f = 1;
  237.   for (int i = 1; i <= n; i++) {
  238.     f *= modinv(i);
  239.     a[i] = i % 2 == 0 ? f : -f;
  240.     b[i] = modpow(i, n) * f;
  241.   }
  242.   a = fft.convolution(a, b);
  243.   a.resize(n + 1);
  244.   return a;
  245. }
  246.  
  247.  
  248. int main() {
  249.   cout << partition(1 << 18)[(1 << 18) - 1] << endl;
  250. }
  251.  
Success #stdin #stdout 1.14s 54696KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
591403914
https://ideone.com/m1LAWr
language:
C++14 (gcc 8.3)
created:
5 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!