fork download
copy 
  1. #pragma GCC optimize ("Ofast")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. #define MD 1000000007
  5. struct mint{
  6.   static unsigned R, RR, Rinv, W, md, mdninv;
  7.   unsigned val;
  8.   mint(){
  9.   }
  10.   mint(int a){
  11.     val = mulR(a);
  12.   }
  13.   mint(unsigned a){
  14.     val = mulR(a);
  15.   }
  16.   mint(long long a){
  17.     val = mulR(a);
  18.   }
  19.   mint(unsigned long long a){
  20.     val = mulR(a);
  21.   }
  22.   int get_inv(long long a, int md){
  23.     long long e, s=md, t=a, u=1, v=0;
  24.     while(s){
  25.       e=t/s;
  26.       t-=e*s;
  27.       u-=e*v;
  28.       swap(t,s);
  29.       swap(u,v);
  30.     }
  31.     if(u<0){
  32.       u+=md;
  33.     }
  34.     return u;
  35.   }
  36.   void setmod(unsigned m){
  37.     int i;
  38.     unsigned t;
  39.     W = 32;
  40.     md = m;
  41.     R = (1ULL << W) % md;
  42.     RR = (unsigned long long)R*R % md;
  43.     switch(m){
  44.       case 104857601:
  45.       Rinv = 2560000;
  46.       mdninv = 104857599;
  47.       break;
  48.       case 998244353:
  49.       Rinv = 232013824;
  50.       mdninv = 998244351;
  51.       break;
  52.       case 1000000007:
  53.       Rinv = 518424770;
  54.       mdninv = 2226617417U;
  55.       break;
  56.       case 1000000009:
  57.       Rinv = 171601999;
  58.       mdninv = 737024967;
  59.       break;
  60.       case 1004535809:
  61.       Rinv = 234947584;
  62.       mdninv = 1004535807;
  63.       break;
  64.       case 1007681537:
  65.       Rinv = 236421376;
  66.       mdninv = 1007681535;
  67.       break;
  68.       case 1012924417:
  69.       Rinv = 238887936;
  70.       mdninv = 1012924415;
  71.       break;
  72.       case 1045430273:
  73.       Rinv = 254466304;
  74.       mdninv = 1045430271;
  75.       break;
  76.       case 1051721729:
  77.       Rinv = 257538304;
  78.       mdninv = 1051721727;
  79.       break;
  80.       default:
  81.       Rinv = get_inv(R, md);
  82.       mdninv = 0;
  83.       t = 0;
  84.       for(i=0;i<((int)W);i++){
  85.         if(t%2==0){
  86.           t+=md;
  87.           mdninv |= (1U<<i);
  88.         }
  89.         t /= 2;
  90.       }
  91.     }
  92.   }
  93.   unsigned mulR(unsigned a){
  94.     return (unsigned long long)a*R%md;
  95.   }
  96.   unsigned mulR(int a){
  97.     if(a < 0){
  98.       a = a%md+md;
  99.     }
  100.     return mulR((unsigned)a);
  101.   }
  102.   unsigned mulR(unsigned long long a){
  103.     return mulR((unsigned)(a%md));
  104.   }
  105.   unsigned mulR(long long a){
  106.     a %= md;
  107.     if(a < 0){
  108.       a += md;
  109.     }
  110.     return mulR((unsigned)a);
  111.   }
  112.   unsigned reduce(unsigned T){
  113.     unsigned m=T * mdninv, t=(unsigned)((T + (unsigned long long)m*md) >> W);
  114.     if(t >= md){
  115.       t -= md;
  116.     }
  117.     return t;
  118.   }
  119.   unsigned reduce(unsigned long long T){
  120.     unsigned m=(unsigned)T * mdninv, t=(unsigned)((T + (unsigned long long)m*md) >> W);
  121.     if(t >= md){
  122.       t -= md;
  123.     }
  124.     return t;
  125.   }
  126.   unsigned get(){
  127.     return reduce(val);
  128.   }
  129.   mint &operator+=(mint a){
  130.     val += a.val;
  131.     if(val >= md){
  132.       val -= md;
  133.     }
  134.     return *this;
  135.   }
  136.   mint &operator-=(mint a){
  137.     if(val < a.val){
  138.       val = val + md - a.val;
  139.     }
  140.     else{
  141.       val -= a.val;
  142.     }
  143.     return *this;
  144.   }
  145.   mint &operator*=(mint a){
  146.     val = reduce((unsigned long long)val*a.val);
  147.     return *this;
  148.   }
  149.   mint &operator/=(mint a){
  150.     return *this *= a.inverse();
  151.   }
  152.   mint operator+(mint a){
  153.     return mint(*this)+=a;
  154.   }
  155.   mint operator-(mint a){
  156.     return mint(*this)-=a;
  157.   }
  158.   mint operator*(mint a){
  159.     return mint(*this)*=a;
  160.   }
  161.   mint operator/(mint a){
  162.     return mint(*this)/=a;
  163.   }
  164.   mint operator+(int a){
  165.     return mint(*this)+=mint(a);
  166.   }
  167.   mint operator-(int a){
  168.     return mint(*this)-=mint(a);
  169.   }
  170.   mint operator*(int a){
  171.     return mint(*this)*=mint(a);
  172.   }
  173.   mint operator/(int a){
  174.     return mint(*this)/=mint(a);
  175.   }
  176.   mint operator+(long long a){
  177.     return mint(*this)+=mint(a);
  178.   }
  179.   mint operator-(long long a){
  180.     return mint(*this)-=mint(a);
  181.   }
  182.   mint operator*(long long a){
  183.     return mint(*this)*=mint(a);
  184.   }
  185.   mint operator/(long long a){
  186.     return mint(*this)/=mint(a);
  187.   }
  188.   mint operator-(void){
  189.     mint res;
  190.     if(val){
  191.       res.val=md-val;
  192.     }
  193.     else{
  194.       res.val=0;
  195.     }
  196.     return res;
  197.   }
  198.   operator bool(void){
  199.     return val!=0;
  200.   }
  201.   operator int(void){
  202.     return get();
  203.   }
  204.   operator long long(void){
  205.     return get();
  206.   }
  207.   mint inverse(){
  208.     int a=val, b=md, t, u=1, v=0;
  209.     mint res;
  210.     while(b){
  211.       t = a / b;
  212.       a -= t * b;
  213.       swap(a, b);
  214.       u -= t * v;
  215.       swap(u, v);
  216.     }
  217.     if(u < 0){
  218.       u += md;
  219.     }
  220.     res.val = (unsigned long long)u*RR % md;
  221.     return res;
  222.   }
  223.   mint pw(unsigned long long b){
  224.     mint a(*this), res;
  225.     res.val = R;
  226.     while(b){
  227.       if(b&1){
  228.         res *= a;
  229.       }
  230.       b >>= 1;
  231.       a *= a;
  232.     }
  233.     return res;
  234.   }
  235.   bool operator==(int a){
  236.     return mulR(a)==val;
  237.   }
  238.   bool operator!=(int a){
  239.     return mulR(a)!=val;
  240.   }
  241. }
  242. ;
  243. mint operator+(int a, mint b){
  244.   return mint(a)+=b;
  245. }
  246. mint operator-(int a, mint b){
  247.   return mint(a)-=b;
  248. }
  249. mint operator*(int a, mint b){
  250.   return mint(a)*=b;
  251. }
  252. mint operator/(int a, mint b){
  253.   return mint(a)/=b;
  254. }
  255. mint operator+(long long a, mint b){
  256.   return mint(a)+=b;
  257. }
  258. mint operator-(long long a, mint b){
  259.   return mint(a)-=b;
  260. }
  261. mint operator*(long long a, mint b){
  262.   return mint(a)*=b;
  263. }
  264. mint operator/(long long a, mint b){
  265.   return mint(a)/=b;
  266. }
  267. unsigned mint::R, mint::RR, mint::Rinv, mint::W, mint::md, mint::mdninv;
  268. #define main dummy_main
  269. int main(){
  270.   {
  271.     mint x;
  272.     x.setmod(MD);
  273.   }
  274.   return 0;
  275. }
  276. #undef main
  277. mint dp[1001];
  278. class Solution{
  279.   public:
  280.   int numRollsToTarget(int d, int f, int target){
  281.     int Lj4PdHRW, i, j, k;
  282.     dummy_main();
  283.     for(i=0;i<(1001);i++){
  284.       dp[i] = 0;
  285.     }
  286.     dp[0] = 1;
  287.     for(Lj4PdHRW=0;Lj4PdHRW<(d);Lj4PdHRW++){
  288.       for(i=1000;i>=0;i--){
  289.         dp[i] = 0;
  290.         for(j=(1);j<(f+1);j++){
  291.           if(i-j < 0){
  292.             break;
  293.           }
  294.           dp[i] += dp[i-j];
  295.         }
  296.       }
  297.     }
  298.     return dp[target];
  299.   }
  300. }
  301. ;
  302. // cLay varsion 20190818-1
  303.  
  304. // --- original code ---
  305. // #define main dummy_main
  306. // {}
  307. // #undef main
  308. // 
  309. // mint dp[1001];
  310. // 
  311. // class Solution {
  312. // public:
  313. //   int numRollsToTarget(int d, int f, int target) {
  314. //     dummy_main();
  315. //     
  316. //     int i, j, k;
  317. //     rep(i,1001) dp[i] = 0;
  318. //     dp[0] = 1;
  319. // 
  320. //     rep(d){
  321. //       for(i=1000;i>=0;i--){
  322. //         dp[i] = 0;
  323. //         rep(j,1,f+1){
  324. //           if(i-j < 0) break;
  325. //           dp[i] += dp[i-j];
  326. //         }
  327. //       }
  328. //     }
  329. // 
  330. //     return dp[target];
  331. //   }
  332. // };
  333.  
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/DlOw4a
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!