fork download
copy 
  1. #pragma GCC optimize ("Ofast")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. #define MD 1000000007
  5. void *wmem;
  6. template<class S, class T> inline S min_L(S a,T b){
  7.   return a<=b?a:b;
  8. }
  9. template<class T> inline void walloc1d(T **arr, int x, void **mem = &wmem){
  10.   static int skip[16]={0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
  11.   (*mem) = (void*)( ((char*)(*mem)) + skip[((unsigned long long)(*mem)) & 15] );
  12.   (*arr)=(T*)(*mem);
  13.   (*mem)=((*arr)+x);
  14. }
  15. struct mint{
  16.   static unsigned R, RR, Rinv, W, md, mdninv;
  17.   unsigned val;
  18.   mint(){
  19.   }
  20.   mint(int a){
  21.     val = mulR(a);
  22.   }
  23.   mint(unsigned a){
  24.     val = mulR(a);
  25.   }
  26.   mint(long long a){
  27.     val = mulR(a);
  28.   }
  29.   mint(unsigned long long a){
  30.     val = mulR(a);
  31.   }
  32.   int get_inv(long long a, int md){
  33.     long long e, s=md, t=a, u=1, v=0;
  34.     while(s){
  35.       e=t/s;
  36.       t-=e*s;
  37.       u-=e*v;
  38.       swap(t,s);
  39.       swap(u,v);
  40.     }
  41.     if(u<0){
  42.       u+=md;
  43.     }
  44.     return u;
  45.   }
  46.   void setmod(unsigned m){
  47.     int i;
  48.     unsigned t;
  49.     W = 32;
  50.     md = m;
  51.     R = (1ULL << W) % md;
  52.     RR = (unsigned long long)R*R % md;
  53.     switch(m){
  54.       case 104857601:
  55.       Rinv = 2560000;
  56.       mdninv = 104857599;
  57.       break;
  58.       case 998244353:
  59.       Rinv = 232013824;
  60.       mdninv = 998244351;
  61.       break;
  62.       case 1000000007:
  63.       Rinv = 518424770;
  64.       mdninv = 2226617417U;
  65.       break;
  66.       case 1000000009:
  67.       Rinv = 171601999;
  68.       mdninv = 737024967;
  69.       break;
  70.       case 1004535809:
  71.       Rinv = 234947584;
  72.       mdninv = 1004535807;
  73.       break;
  74.       case 1007681537:
  75.       Rinv = 236421376;
  76.       mdninv = 1007681535;
  77.       break;
  78.       case 1012924417:
  79.       Rinv = 238887936;
  80.       mdninv = 1012924415;
  81.       break;
  82.       case 1045430273:
  83.       Rinv = 254466304;
  84.       mdninv = 1045430271;
  85.       break;
  86.       case 1051721729:
  87.       Rinv = 257538304;
  88.       mdninv = 1051721727;
  89.       break;
  90.       default:
  91.       Rinv = get_inv(R, md);
  92.       mdninv = 0;
  93.       t = 0;
  94.       for(i=0;i<((int)W);i++){
  95.         if(t%2==0){
  96.           t+=md;
  97.           mdninv |= (1U<<i);
  98.         }
  99.         t /= 2;
  100.       }
  101.     }
  102.   }
  103.   unsigned mulR(unsigned a){
  104.     return (unsigned long long)a*R%md;
  105.   }
  106.   unsigned mulR(int a){
  107.     if(a < 0){
  108.       a = a%((int)md)+(int)md;
  109.     }
  110.     return mulR((unsigned)a);
  111.   }
  112.   unsigned mulR(unsigned long long a){
  113.     return mulR((unsigned)(a%md));
  114.   }
  115.   unsigned mulR(long long a){
  116.     a %= md;
  117.     if(a < 0){
  118.       a += md;
  119.     }
  120.     return mulR((unsigned)a);
  121.   }
  122.   unsigned reduce(unsigned T){
  123.     unsigned m=T * mdninv, t=(unsigned)((T + (unsigned long long)m*md) >> W);
  124.     if(t >= md){
  125.       t -= md;
  126.     }
  127.     return t;
  128.   }
  129.   unsigned reduce(unsigned long long T){
  130.     unsigned m=(unsigned)T * mdninv, t=(unsigned)((T + (unsigned long long)m*md) >> W);
  131.     if(t >= md){
  132.       t -= md;
  133.     }
  134.     return t;
  135.   }
  136.   unsigned get(){
  137.     return reduce(val);
  138.   }
  139.   mint &operator+=(mint a){
  140.     val += a.val;
  141.     if(val >= md){
  142.       val -= md;
  143.     }
  144.     return *this;
  145.   }
  146.   mint &operator-=(mint a){
  147.     if(val < a.val){
  148.       val = val + md - a.val;
  149.     }
  150.     else{
  151.       val -= a.val;
  152.     }
  153.     return *this;
  154.   }
  155.   mint &operator*=(mint a){
  156.     val = reduce((unsigned long long)val*a.val);
  157.     return *this;
  158.   }
  159.   mint &operator/=(mint a){
  160.     return *this *= a.inverse();
  161.   }
  162.   mint operator+(mint a){
  163.     return mint(*this)+=a;
  164.   }
  165.   mint operator-(mint a){
  166.     return mint(*this)-=a;
  167.   }
  168.   mint operator*(mint a){
  169.     return mint(*this)*=a;
  170.   }
  171.   mint operator/(mint a){
  172.     return mint(*this)/=a;
  173.   }
  174.   mint operator+(int a){
  175.     return mint(*this)+=mint(a);
  176.   }
  177.   mint operator-(int a){
  178.     return mint(*this)-=mint(a);
  179.   }
  180.   mint operator*(int a){
  181.     return mint(*this)*=mint(a);
  182.   }
  183.   mint operator/(int a){
  184.     return mint(*this)/=mint(a);
  185.   }
  186.   mint operator+(long long a){
  187.     return mint(*this)+=mint(a);
  188.   }
  189.   mint operator-(long long a){
  190.     return mint(*this)-=mint(a);
  191.   }
  192.   mint operator*(long long a){
  193.     return mint(*this)*=mint(a);
  194.   }
  195.   mint operator/(long long a){
  196.     return mint(*this)/=mint(a);
  197.   }
  198.   mint operator-(void){
  199.     mint res;
  200.     if(val){
  201.       res.val=md-val;
  202.     }
  203.     else{
  204.       res.val=0;
  205.     }
  206.     return res;
  207.   }
  208.   operator bool(void){
  209.     return val!=0;
  210.   }
  211.   operator int(void){
  212.     return get();
  213.   }
  214.   operator long long(void){
  215.     return get();
  216.   }
  217.   mint inverse(){
  218.     int a=val, b=md, t, u=1, v=0;
  219.     mint res;
  220.     while(b){
  221.       t = a / b;
  222.       a -= t * b;
  223.       swap(a, b);
  224.       u -= t * v;
  225.       swap(u, v);
  226.     }
  227.     if(u < 0){
  228.       u += md;
  229.     }
  230.     res.val = (unsigned long long)u*RR % md;
  231.     return res;
  232.   }
  233.   mint pw(unsigned long long b){
  234.     mint a(*this), res;
  235.     res.val = R;
  236.     while(b){
  237.       if(b&1){
  238.         res *= a;
  239.       }
  240.       b >>= 1;
  241.       a *= a;
  242.     }
  243.     return res;
  244.   }
  245.   bool operator==(int a){
  246.     return mulR(a)==val;
  247.   }
  248.   bool operator!=(int a){
  249.     return mulR(a)!=val;
  250.   }
  251. }
  252. ;
  253. mint operator+(int a, mint b){
  254.   return mint(a)+=b;
  255. }
  256. mint operator-(int a, mint b){
  257.   return mint(a)-=b;
  258. }
  259. mint operator*(int a, mint b){
  260.   return mint(a)*=b;
  261. }
  262. mint operator/(int a, mint b){
  263.   return mint(a)/=b;
  264. }
  265. mint operator+(long long a, mint b){
  266.   return mint(a)+=b;
  267. }
  268. mint operator-(long long a, mint b){
  269.   return mint(a)-=b;
  270. }
  271. mint operator*(long long a, mint b){
  272.   return mint(a)*=b;
  273. }
  274. mint operator/(long long a, mint b){
  275.   return mint(a)/=b;
  276. }
  277. int Prime_L(int N, int res[], void *mem=wmem){
  278.   bool *isprime;
  279.   const int r=23000;
  280.   int a, b, i, *sf, ss=1, sz=1;
  281.   walloc1d(&isprime, r, &mem);
  282.   walloc1d(&sf, r, &mem);
  283.   isprime = (bool*)mem;
  284.   sf = (int*)(isprime + r);
  285.   N /= 2;
  286.   res[0] = 2;
  287.   b =min_L(r, N);
  288.   for(i=(1);i<(b);i++){
  289.     isprime[i] = 1;
  290.   }
  291.   for(i=(1);i<(b);i++){
  292.     if(isprime[i]){
  293.       res[sz++] = 2*i+1;
  294.       sf[ss] = 2*i*(i+1);
  295.       if(sf[ss] < N){
  296.         while(sf[ss] < r){
  297.           isprime[sf[ss]] = 0;
  298.           sf[ss] += res[ss];
  299.         }
  300.         ss++;
  301.       }
  302.     }
  303.   }
  304.   for(a=r; a<N; a+=r){
  305.     b =min_L(a + r, N);
  306.     isprime -= r;
  307.     for(i=(a);i<(b);i++){
  308.       isprime[i] = 1;
  309.     }
  310.     for(i=(1);i<(ss);i++){
  311.       while(sf[i] < b){
  312.         isprime[sf[i]] = 0;
  313.         sf[i] += res[i];
  314.       }
  315.     }
  316.     for(i=(a);i<(b);i++){
  317.       if(isprime[i]){
  318.         res[sz++] = 2*i+1;
  319.       }
  320.     }
  321.   }
  322.   return sz;
  323. }
  324. char memarr[96000000];
  325. unsigned mint::R, mint::RR, mint::Rinv, mint::W, mint::md, mint::mdninv;
  326. #define main dummy_main
  327. int main(){
  328.   wmem = memarr;
  329.   {
  330.     mint x;
  331.     x.setmod(MD);
  332.   }
  333.   return 0;
  334. }
  335. #undef main
  336. int ps;
  337. int p[101];
  338. mint fact[101];
  339. class Solution{
  340.   public:
  341.   int numPrimeArrangements(int n){
  342.     int i;
  343.     dummy_main();
  344.     ps =Prime_L(n+1, p);
  345.     fact[0] = 1;
  346.     for(i=(1);i<(n+1);i++){
  347.       fact[i] = fact[i-1] * i;
  348.     }
  349.     return fact[ps] * fact[n-ps];
  350.   }
  351. }
  352. ;
  353. // cLay varsion 20190830-1
  354.  
  355. // --- original code ---
  356. // #define main dummy_main
  357. // {}
  358. // #undef main
  359. // 
  360. // int ps, p[101];
  361. // mint fact[101];
  362. // 
  363. // class Solution {
  364. // public:
  365. //   int numPrimeArrangements(int n) {
  366. //     dummy_main();
  367. //     ps = Prime(n+1, p);
  368. //     fact[0] = 1;
  369. //     rep(i,1,n+1) fact[i] = fact[i-1] * i;
  370. //     return fact[ps] * fact[n-ps];
  371. //   }
  372. // };
  373.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x20): undefined reference to `main'
collect2: error: ld returned 1 exit status
stdout
copy 
Standard output is empty
https://ideone.com/cD5VSi
language:
C++14 (gcc 8.3)
created:
4 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!