SHARE
TWEET

idlemosnterthoery(wavefunction)

a guest May 22nd, 2019 66 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <math.h>
  3. #include <cstdlib>
  4. #include <conio.h>
  5. #include <ctime>
  6. #include <string>
  7. #include <cstdio>
  8.  
  9. using namespace std;
  10.  
  11. const int finalT = 40000;
  12. const int finalX = 7000;
  13. const int jewelX = 3502;
  14. float T = 0.375;
  15. int book = 8;
  16. float pskip = 0.5;
  17. float state [finalX+1][1001] = {};
  18. float temp [finalX+1][1001] = {};
  19. int mobs [finalX+1]={};
  20. int maxlvl [finalT+1]={};
  21. int minlvl [finalT+1]={};
  22. double relic [finalX+1]={};
  23. float roll [11]={0, .1, .1, .1, .1, .1, .1, .1, .1, .1, .1};
  24.  
  25.  
  26. int mobcount()
  27. {
  28.     mobs[0] = 10 - book;
  29.     int counter = 1;
  30.     int dounter = 1;
  31.     for (int i = 1; i<=finalX; i++)
  32.     {
  33.         if (counter == 500)
  34.         {
  35.             mobs[i] = mobs[i-1] + 2;
  36.             counter = 1;
  37.         }
  38.         else
  39.             mobs[i]=mobs[i-1];
  40.  
  41.         if(i>=500)
  42.             counter ++;
  43.     }
  44.  
  45.     for (int i = 1; i<=finalX; i++)
  46.         if (mobs[i]<=0)
  47.             mobs[i]=1;
  48.  
  49.     cout<<"maxmobs: "<<mobs[finalX]<<endl;
  50.     counter=1;
  51.     maxlvl[0]=1;
  52.     minlvl[0]=1;
  53.     for (int t=1; t<= finalT; t++)
  54.     {
  55.  
  56.         if (dounter==mobs[maxlvl[t-1]]+1)
  57.         {
  58.             if(maxlvl[t-1]<=jewelX)
  59.                 maxlvl[t]=maxlvl[t-1]+10;
  60.             else
  61.                 maxlvl[t]=maxlvl[t-1]+1;
  62.  
  63.             dounter=0;
  64.         }
  65.         else
  66.         {
  67.             maxlvl[t]=maxlvl[t-1];
  68.         }
  69.         if (counter==mobs[minlvl[t-1]]+1)
  70.         {
  71.             minlvl[t]=minlvl[t-1]+1;
  72.             counter=0;
  73.         }
  74.         else
  75.         {
  76.             minlvl[t]=minlvl[t-1];
  77.         }
  78.         //cout<<t<<" maxlevel: " <<maxlvl[t]<< "\t minlevel: "<< minlvl[t]<< endl;
  79.         dounter++;
  80.         counter++;
  81.     }
  82.  
  83.     cout<<finalT<<" maxlevel: " <<maxlvl[finalT]<< "\t minlevel: "<< minlvl[finalT]<< endl;
  84.     cout<<"When considering <level> at fixed time, \n ensure you consider the value of maxlevel at that time."<<endl;
  85.     cout<<"When considering <surtime> at fixed level, \n ensure you consider the value of time at that minlevel."<<endl;
  86.  
  87.     for (int i=50; i<=finalX; i++)
  88.     {
  89.         relic[i]= relic[i-10]+pow((i-40.0), 1.5);
  90.         //cout<<i<<" relics: "<< relics[i] <<endl;
  91.     }
  92.  
  93.     return 0;
  94. }
  95. int initial ()
  96. {
  97.     mobcount();
  98.     for (int i = 0; i<=finalX; i++)
  99.     {
  100.         for (int j=0; j <= mobs[i]+1; j++)
  101.         {
  102.             temp[i][j]=0.0;
  103.             state[i][j]=0.0;
  104.         }
  105.     }
  106.  
  107.     return 0;
  108. }
  109.  
  110. int F (int x)
  111. {
  112.     if (x>0)
  113.         return x;
  114.     else
  115.         return 0;
  116. }
  117. int main ()
  118. {
  119.     initial();
  120.     //freopen("output.txt","w",stdout);
  121.     float avglvl = 0.0;
  122.     double avgrate = 0.0;
  123.     float avgtime[finalX+1]= {};
  124.     float avgtimesurpass[finalX+1]={};
  125.     double avgreciptsurpass[finalX+1]={};
  126.     int t=0;
  127.     int bestspace = 1;
  128.     double bestspacerate = 0.0;
  129.     int besttime = 0;
  130.     double besttimerate = 0.0;
  131.     int besttimeavglvl = 1;
  132.  
  133.  
  134.     for(int a=1; 1<=a && a<=mobs[1]+1; a++)
  135.     {
  136.         if(a==mobs[1]+1)
  137.             state[1][0]=1.0;
  138.         else
  139.             state[1][a]=1.0;
  140.         cout<<"psi(1)"<<"("<<a%(mobs[1]+1)<<")"<<"("<<t<<")"<<" = " << state[1][a%(mobs[1]+1)]<<endl;
  141.         t++;
  142.     }
  143.  
  144.     for (int i = 0; i<=finalX; i++)
  145.     {
  146.         for (int j=0; j <= mobs[i]+1; j++)
  147.         {
  148.             temp[i][j]=0.0;
  149.             state[i][j]=0.0;
  150.         }
  151.     }
  152.     temp[1][0]=1;
  153.  
  154.     while (t<=finalT)
  155.     {
  156.         for (int i=2; i<= finalX; i++)
  157.         {
  158.             for (int j=1; j <= mobs[i]+1; j++)
  159.             {
  160.  
  161.                 if(j==1)
  162.                 {
  163.                     if (i<=jewelX+1)
  164.                         state[i][1]= temp[i-1][0]*(1-pskip) + (pskip)*
  165.                     (temp[F(i-2)][0]*roll[1] + temp[F(i-3)][0]*roll[2] + temp[F(i-4)][0]*roll[3] +
  166.                      temp[F(i-5)][0]*roll[4] + temp[F(i-6)][0]*roll[5] + temp[F(i-7)][0]*roll[6] +
  167.                      temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  168.                      temp[F(i-11)][0]*roll[10]);
  169.  
  170.                     else if (i<=jewelX+11)
  171.                     {
  172.                         if (i==jewelX+2)
  173.                         state[i][1]= temp[i-1][0] + (pskip)*
  174.                     (temp[F(i-2)][0]*roll[1]+ temp[F(i-3)][0]*roll[2] + temp[F(i-4)][0]*roll[3] +
  175.                      temp[F(i-5)][0]*roll[4] + temp[F(i-6)][0]*roll[5] + temp[F(i-7)][0]*roll[6] +
  176.                      temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  177.                      temp[F(i-11)][0]*roll[10]);
  178.  
  179.                         else if (i==jewelX+3)
  180.                             state[i][1]= temp[i-1][0] + (pskip)*
  181.                     (temp[F(i-3)][0]*roll[2]+ temp[F(i-4)][0]*roll[3] +
  182.                      temp[F(i-5)][0]*roll[4] + temp[F(i-6)][0]*roll[5] + temp[F(i-7)][0]*roll[6] +
  183.                      temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  184.                      temp[F(i-11)][0]*roll[10]);
  185.  
  186.                          else if (i==jewelX+4)
  187.                                 state[i][1]= temp[i-1][0] + (pskip)*
  188.                         (temp[F(i-4)][0]*roll[3]+ temp[F(i-5)][0]*roll[4] + temp[F(i-6)][0]*roll[5] + temp[F(i-7)][0]*roll[6] +
  189.                          temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  190.                          temp[F(i-11)][0]*roll[10]);
  191.  
  192.                          else if (i==jewelX+5)
  193.                                 state[i][1]= temp[i-1][0] + (pskip)*
  194.                         (temp[F(i-5)][0]*roll[4] + temp[F(i-6)][0]*roll[5] + temp[F(i-7)][0]*roll[6] +
  195.                          temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  196.                          temp[F(i-11)][0]*roll[10]);
  197.  
  198.                          else if (i==jewelX+6)
  199.                                 state[i][1]= temp[i-1][0] + (pskip)*
  200.                         (temp[F(i-6)][0]*roll[5] + temp[F(i-7)][0]*roll[6] +
  201.                          temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  202.                          temp[F(i-11)][0]*roll[10]);
  203.  
  204.                          else if (i==jewelX+7)
  205.                                 state[i][1]= temp[i-1][0] + (pskip)*
  206.                         (temp[F(i-7)][0]*roll[6] +
  207.                          temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  208.                          temp[F(i-11)][0]*roll[10]);
  209.  
  210.                          else if (i==jewelX+8)
  211.                                 state[i][1]= temp[i-1][0] + (pskip)*
  212.                         (temp[F(i-8)][0]*roll[7] + temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  213.                          temp[F(i-11)][0]*roll[10]);
  214.  
  215.                          else if (i==jewelX+9)
  216.                                 state[i][1]= temp[i-1][0] + (pskip)*
  217.                         (temp[F(i-9)][0]*roll[9] + temp[F(i-10)][0]*roll[9] +
  218.                          temp[F(i-11)][0]*roll[10]);
  219.  
  220.                          else if (i==jewelX+10)
  221.                                 state[i][1]= temp[i-1][0] + (pskip)*
  222.                         (temp[F(i-10)][0]*roll[9] +
  223.                          temp[F(i-11)][0]*roll[10]);
  224.  
  225.                          else if (i==jewelX+11)
  226.                                 state[i][1]= temp[i-1][0] + (pskip)*
  227.                         (temp[F(i-11)][0]*roll[10]);
  228.  
  229.                     }
  230.  
  231.                     else
  232.                         state[i][1]= temp[i-1][0];
  233.  
  234.                 }
  235.  
  236.  
  237.                 else
  238.                     state [i][j%(mobs[i]+1)] = temp[i][j-1];
  239.  
  240.  
  241.  
  242.  
  243.                 if (state[i][j%(mobs[i]+1)] != 0.0)
  244.                 {
  245.                      //cout<<"psi("<<i<<")"<<"("<<j%(mobs[i]+1)<<")"<<"("<<t<<")"<<" = " <<
  246.                     //state[i][j%(mobs[i]+1)]<<endl;
  247.                     avglvl=avglvl+(float(i)*state[i][j%(mobs[i]+1)]);
  248.                     avgrate=avgrate+(relic[i]*state[i][j%(mobs[i]+1)])/(0.0+t);
  249.                     avgtime[i]=avgtime[i] + ((t+0.0)*state[i][j%(mobs[i]+1)]);
  250.  
  251.                     if (i<=finalX-11 && j==mobs[i]+1)
  252.                     {
  253.                         if (i<=jewelX)
  254.                         {
  255.                             avgtimesurpass[i+1]=avgtimesurpass[i+1]+ (t+1)*
  256.                             state[i][0];
  257.                             avgtimesurpass[i+2]=avgtimesurpass[i+2]+ (t+1)*
  258.                             state[i][0]*pskip;
  259.                             avgtimesurpass[i+3]=avgtimesurpass[i+3]+ (t+1)*
  260.                             state[i][0]*pskip*(1-roll[1]);
  261.                             avgtimesurpass[i+4]=avgtimesurpass[i+4]+ (t+1)*
  262.                             state[i][0]*pskip*(1-(roll[1]+roll[2]));
  263.                             avgtimesurpass[i+5]=avgtimesurpass[i+5]+ (t+1)*
  264.                             state[i][0]*pskip*(1-(roll[1]+roll[2]+roll[3]));
  265.                             avgtimesurpass[i+6]=avgtimesurpass[i+6]+ (t+1)*
  266.                             state[i][0]*pskip*(1-(roll[1]+roll[2]+roll[3]+roll[4]));
  267.                             avgtimesurpass[i+7]=avgtimesurpass[i+7]+ (t+1)*
  268.                             state[i][0]*pskip*(roll[6]+roll[7]+roll[8]+roll[9]+roll[10]);
  269.                             avgtimesurpass[i+8]=avgtimesurpass[i+8]+ (t+1)*
  270.                             state[i][0]*pskip*(roll[7]+roll[8]+roll[9]+roll[10]);
  271.                             avgtimesurpass[i+9]=avgtimesurpass[i+9]+ (t+1)*
  272.                             state[i][0]*pskip*(roll[8]+roll[9]+roll[10]);
  273.                             avgtimesurpass[i+10]=avgtimesurpass[i+10]+ (t+1)*
  274.                             state[i][0]*pskip*(roll[9]+roll[10]);
  275.                             avgtimesurpass[i+11]=avgtimesurpass[i+11]+ (t+1)*
  276.                             state[i][0]*pskip*(roll[10]);
  277.  
  278.                             avgreciptsurpass[i+1]=avgreciptsurpass[i+1]+ (relic[i+1]/(t+1))*
  279.                             state[i][0];
  280.                             avgreciptsurpass[i+2]=avgreciptsurpass[i+2]+ (relic[i+2]/(t+1))*
  281.                             state[i][0]*pskip;
  282.                             avgreciptsurpass[i+3]=avgreciptsurpass[i+3]+ (relic[i+3]/(t+1))*
  283.                             state[i][0]*pskip*(1-roll[1]);
  284.                             avgreciptsurpass[i+4]=avgreciptsurpass[i+4]+ (relic[i+4]/(t+1))*
  285.                             state[i][0]*pskip*(1-(roll[1]+roll[2]));
  286.                             avgreciptsurpass[i+5]=avgreciptsurpass[i+5]+ (relic[i+5]/(t+1))*
  287.                             state[i][0]*pskip*(1-(roll[1]+roll[2]+roll[3]));
  288.                             avgreciptsurpass[i+6]=avgreciptsurpass[i+6]+ (relic[i+6]/(t+1))*
  289.                             state[i][0]*pskip*(1-(roll[1]+roll[2]+roll[3]+roll[4]));
  290.                             avgreciptsurpass[i+7]=avgreciptsurpass[i+7]+ (relic[i+7]/(t+1))*
  291.                             state[i][0]*pskip*(roll[6]+roll[7]+roll[8]+roll[9]+roll[10]);
  292.                             avgreciptsurpass[i+8]=avgreciptsurpass[i+8]+ (relic[i+8]/(t+1))*
  293.                             state[i][0]*pskip*(roll[7]+roll[8]+roll[9]+roll[10]);
  294.                             avgreciptsurpass[i+9]=avgreciptsurpass[i+9]+ (relic[i+9]/(t+1))*
  295.                             state[i][0]*pskip*(roll[8]+roll[9]+roll[10]);
  296.                             avgreciptsurpass[i+10]=avgreciptsurpass[i+10]+ (relic[i+10]/(t+1))*
  297.                             state[i][0]*pskip*(roll[9]+roll[10]);
  298.                             avgreciptsurpass[i+11]=avgreciptsurpass[i+11]+ (relic[i+11]/(t+1))*
  299.                             state[i][0]*pskip*(roll[10]);
  300.                         }
  301.  
  302.                         else
  303.                         {
  304.                             avgtimesurpass[i+1]=avgtimesurpass[i+1]+ (t+1)*
  305.                             state[i][0];
  306.  
  307.                             avgreciptsurpass[i+1]=avgreciptsurpass[i+1]+ (relic[i+1]/(t+1))*
  308.                             state[i][0];
  309.                         }
  310.  
  311.  
  312.                     }
  313.  
  314.                 }
  315.  
  316.             }
  317.  
  318.         }
  319.  
  320.  
  321.         for (int i=1; i<= finalX; i++)
  322.             for (int j=1; j <= mobs[i]+1; j++)
  323.                 temp[i][j%(mobs[i]+1)]=state[i][j%(mobs[i]+1)];
  324.  
  325.         /*if (t%100 == 0)
  326.         {
  327.             cout<< "time: "<<t<<" <level>: "<<avglvl<<"\t <rate>: "<< avgrate<< endl;
  328.         }*/
  329.  
  330.         if (avgrate >= besttimerate)
  331.         {
  332.             besttimerate=avgrate;
  333.             besttime=t;
  334.             besttimeavglvl = avglvl;
  335.         }
  336.  
  337.         avglvl=0.0;
  338.         avgrate=0.0;
  339.  
  340.  
  341.         t++;
  342.     }
  343.  
  344.     for (int i=10; i<= finalX; i=i+10)
  345.     {
  346.         if (avgreciptsurpass[i]>=bestspacerate)
  347.         {
  348.             bestspacerate=avgreciptsurpass[i];
  349.             bestspace=i;
  350.         }
  351.  
  352.     }
  353.  
  354.     cout<<"first is idle strategy with fixed time. second with fixed space."<<endl;
  355.     cout <<"reach time: "<<besttime<<" <reached level>: "<<besttimeavglvl << " <rate>: " <<besttimerate <<endl;
  356.     cout<<"surpass level: "<<bestspace<<" <surpass time>: " <<avgtimesurpass[bestspace]<< " <rate>: " << bestspacerate <<endl;
  357.  
  358.  
  359.  
  360.  
  361.     return 0;
  362. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top