fork(5) download 
  1. #include <stdio.h>
  2. #include <vector>
  3. #include <list>
  4. #include <map>
  5. #include <set>
  6. #include <queue>
  7. #include <deque>
  8. #include <stack>
  9. #include <bitset>
  10. #include <algorithm>
  11. #include <functional>
  12. #include <numeric>
  13. #include <utility>
  14. #include <sstream>
  15. #include <iostream>
  16. #include <iomanip>
  17. #include <cstdio>
  18. #include <cmath>
  19. #include <cstdlib>
  20. #include <ctime>
  21. #include <cstring>
  22. #include <string>
  23. #include <queue>
  24. #include <cstdio>
  25. #include <fstream>
  26.  
  27. using namespace std;
  28.  
  29. int glbl_counter=0;
  30. int glbl_time_counter=0;
  31. int glbl_eff_cases=0;
  32. int Start_indx=0;
  33. int End_indx=0;
  34.  
  35. ofstream outputFile("Testing.txt");
  36.  
  37.  
  38. struct solution {
  39. char SubmissionState;
  40. int Sol_time;
  41. solution()
  42. {
  43. Sol_time=0;
  44. SubmissionState='Z';
  45. }
  46. };
  47.  
  48. struct Question
  49. {
  50. int id;
  51. bool Solved;
  52. int NUM_SOL;
  53. int Qtotal_time;
  54. solution sol[30];
  55. Question()
  56. {
  57. NUM_SOL=0;
  58. id=0;
  59. Solved=false;
  60. Qtotal_time=0;
  61. }
  62.  
  63. public: void Clean_Question()
  64. {
  65. Question();
  66. for(int i=0;i<30;i++)
  67. {
  68.    sol[i].Sol_time=0;
  69.    sol[i].SubmissionState='U';
  70. }
  71.  
  72. }
  73. };
  74.  
  75. struct Contest{
  76. Question Q[15];
  77. int id;
  78. bool Defined;
  79. int total_time;
  80. Contest()
  81. {
  82. Defined=false;
  83. total_time=0;
  84. }
  85.  
  86. public: void Clean_contest()
  87. {
  88. Contest();
  89. for(int i=0;i<15;i++)
  90. {
  91.    Q[i].Clean_Question();
  92. }
  93.  
  94. }
  95. };
  96.  
  97. void Solve_Case(Contest CON[]);
  98. void ModifiedselectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx);
  99. void selectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx);
  100.  
  101. int main()
  102. {
  103.    Contest contest[105];
  104.    //Read input lines
  105.    string s;
  106.    int NoOfCases;
  107.    char p[30];
  108.  
  109.    int i1,i0,i2;
  110.    char x[2];
  111.    bool Flag=false;
  112.    bool EXITFLAG=false;
  113.  
  114.       getline(cin,s);
  115.       NoOfCases=atoi(s.c_str());
  116.       if(NoOfCases==0)
  117.          exit (EXIT_SUCCESS);
  118.       getline(cin,s);
  119.    //Get first line, if empty terminate.
  120.       while(true)
  121.       {
  122.  
  123.       while(true)
  124.       {
  125.          getline (cin, s);
  126.          if(s==""&&Flag)//Case Ends
  127.          {
  128.          //glbl_counter++;
  129.          Flag=false;
  130.          //Solve problem for the previous case before reading new case, and print.
  131.          //Contest *ptr = &(contest);
  132.          Solve_Case(contest);
  133.          for(int i=0;i<101;i++)
  134.          {
  135.          contest[i]=contest[0];
  136.          }
  137.          /*if(glbl_counter>=NoOfCases)
  138.          {
  139.          break;
  140.          }*/
  141.          break;
  142.          }
  143.          copy(s.begin(), s.end(), p);
  144.          p[s.size()]='\0';
  145.          sscanf (p,"%d %d %d %s",&i0,&i1,&i2,x);
  146.          //printf ("%d %d %d %c\n",i0,i1,i2,x[0]);
  147.          if(contest[i0].Defined==false)
  148.             contest[i0].Defined=true;
  149.          contest[i0].id=i0;
  150.          contest[i0].Q[i1].id=i1;
  151.          contest[i0].Q[i1].sol[contest[i0].Q[i1].NUM_SOL].SubmissionState=x[0];
  152.          contest[i0].Q[i1].sol[contest[i0].Q[i1].NUM_SOL].Sol_time=i2;
  153.          contest[i0].Q[i1].Solved=true;
  154.          contest[i0].Q[i1].NUM_SOL++;
  155.          glbl_time_counter++;
  156.          Flag=true;
  157.       }
  158.       NoOfCases--;
  159.       if(NoOfCases==0)
  160.          break;
  161.       else
  162.          {
  163.          cout<<endl;
  164.          outputFile<<endl;
  165.          }
  166.  
  167.       }
  168.  
  169.       return 0;
  170. }
  171.  
  172.  
  173. void Solve_Case( Contest CON[])
  174. {
  175.    glbl_eff_cases++;
  176.    int List[105][3];
  177.    int CorrectSequence=0;
  178.    int counter=0;
  179.    int INCORRECT_counter=0;
  180.    int SolvedCounter=0;
  181.    bool flag=false;
  182.    for(int i=0;i<101;i++)
  183.    {
  184.    if(CON[i].Defined)
  185.  
  186.    {
  187.    for(int j=0;j<16;j++)
  188.    {
  189.       if(CON[i].Q[j].Solved)
  190.       {
  191.          for(int k=CON[i].Q[j].NUM_SOL-1;k>=0;k--)
  192.          {
  193.             if(!(CON[i].Q[j].sol[k].SubmissionState=='C'||CON[i].Q[j].sol[k].SubmissionState=='I'))
  194.                continue;
  195.             else{
  196.  
  197.          if(CON[i].Q[j].sol[k].SubmissionState=='C'&&!flag)
  198.          {
  199.             flag=true;
  200.             CON[i].Q[j].Qtotal_time+=CON[i].Q[j].sol[k].Sol_time;
  201.             CorrectSequence=CON[i].Q[j].sol[k].Sol_time;
  202.             SolvedCounter++;
  203.             continue;
  204.          }
  205.          /*if(CON[i].Q[j].sol[k].SubmissionState=='C'&&flag);
  206.          {
  207.             continue;
  208.          }*/
  209.          if(CON[i].Q[j].sol[k].SubmissionState=='C'&&flag)
  210.          {
  211.             CON[i].Q[j].Qtotal_time+=CON[i].Q[j].sol[k].Sol_time;
  212.             CON[i].Q[j].Qtotal_time-=CorrectSequence;
  213.             CON[i].Q[j].Qtotal_time=CON[i].Q[j].Qtotal_time-20*INCORRECT_counter;
  214.             CorrectSequence=CON[i].Q[j].sol[k].Sol_time;
  215.             INCORRECT_counter=0;
  216.             continue;
  217.          }
  218.  
  219.          if(CON[i].Q[j].sol[k].SubmissionState=='I'&&flag)
  220.          {
  221.          CON[i].Q[j].Qtotal_time+=20;
  222.          INCORRECT_counter++;
  223.          continue;
  224.          }
  225.             }
  226.          }
  227.       }
  228.  
  229.       flag=false;
  230.       CON[i].total_time+=CON[i].Q[j].Qtotal_time;
  231.       CorrectSequence=0;
  232.       INCORRECT_counter=0;
  233.    }
  234.       List[counter][0]=CON[i].id;
  235.       List[counter][1]=SolvedCounter;
  236.       List[counter][2]=CON[i].total_time;
  237.       counter++;
  238.       SolvedCounter=0;
  239.    }
  240.  
  241.    }
  242.  
  243.    //Sorting Phase
  244.    /********************* *********************/
  245.    /********************* *********************/
  246.    /********************* *********************/
  247.    int starting_indx;
  248.    int counter2=0;
  249.    bool flag2=false;
  250.    ModifiedselectionSort(List,1,0,counter);
  251.  
  252.    int temp_value;
  253.    temp_value=List[Start_indx][1];
  254.  
  255.    for(int i=Start_indx+1;i<counter+1;i++)
  256.    {
  257.    temp_value=List[i-1][1];
  258.    if(List[i][1]==temp_value)
  259.    {
  260.    End_indx=i;
  261.    counter2++;
  262.    }
  263.    else
  264.    {
  265.       if(counter2>0)
  266.       {
  267.       selectionSort(List,2,Start_indx,End_indx);
  268.       counter2=0;
  269.       }
  270.       Start_indx=i;
  271.  
  272.    }
  273.    }
  274.    selectionSort(List,2,Start_indx,End_indx);
  275.  
  276.    Start_indx=0;
  277.    End_indx=0;
  278.    temp_value=List[Start_indx][0];
  279.    for(int i=Start_indx+1;i<counter+1;i++)
  280.    {
  281.    temp_value=List[i-1][2];
  282.    if(List[i][2]==temp_value)
  283.    {
  284.    End_indx=i;
  285.    counter2++;
  286.    }
  287.    else
  288.    {
  289.       if(counter2>0)
  290.       {
  291.       selectionSort(List,0,Start_indx,End_indx);
  292.       counter2=0;
  293.       }
  294.       Start_indx=i;
  295.  
  296.    }
  297.    }
  298.    selectionSort(List,0,Start_indx,End_indx);
  299.    Start_indx=0;
  300.    End_indx=0;
  301.  
  302.    /********************* *********************/
  303.    /********************* *********************/
  304.    /********************* *********************/
  305.  
  306.    for(int i=0;i<counter;i++)
  307.    {
  308.       //if(glbl_eff_cases>0&& i==0)
  309.       //   cout<<endl<<endl;
  310.  
  311.       ////
  312.       //if(i!=counter-1)
  313.       cout<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2]<<endl;
  314.       outputFile<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2]<<endl;
  315.       /*else
  316.       {
  317.       cout<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2];
  318.       glbl_eff_cases++;
  319.       }*/
  320.    }
  321.  
  322.    /*if(NO_CASES>1)
  323.    {
  324.       cout<<endl;
  325.       outputFile<<endl;
  326.    }*/
  327.  
  328.    //for(int i=0;i<counter;i++)
  329.    //{
  330.    //   /*if(glbl_eff_cases>1&& i==0)
  331.    //      outputFile<<endl<<endl;
  332.    //   
  333.    //   
  334.    //   if(i!=counter-1)*/
  335.    //   outputFile<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2]<<endl;
  336.    //   /*else
  337.    //   {
  338.    //   outputFile<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2];
  339.    //   }
  340.    //   */
  341.    //}
  342.    //if(NO_CASES>1&&glbl_eff_cases!=NO_CASES)
  343.    //   outputFile<<endl;
  344.    //return List;
  345. }
  346.  
  347.  
  348. void selectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx) {
  349.  
  350.       int i, j, minIndex, tmp1,tmp2,tmp3;   
  351.  
  352.       for (i = Start_indx; i < End_indx; i++) {
  353.  
  354.             minIndex = i;
  355.  
  356.             for (j = i + 1; j < End_indx+1; j++)
  357.  
  358.                   if (arr[j][indx_to_sort_on] < arr[minIndex][indx_to_sort_on])
  359.  
  360.                         minIndex = j;
  361.  
  362.             if (minIndex != i) {
  363.  
  364.                   tmp1 = arr[i][0];
  365.               tmp2 = arr[i][1];
  366.               tmp3= arr[i][2];
  367.  
  368.                   arr[i][0] = arr[minIndex][0];
  369.               arr[i][1] = arr[minIndex][1];
  370.               arr[i][2] = arr[minIndex][2];
  371.                   arr[minIndex][0] = tmp1;
  372.               arr[minIndex][1] = tmp2;
  373.               arr[minIndex][2] = tmp3;
  374.  
  375.             }
  376.  
  377.       }
  378.  
  379. }
  380.  
  381.  
  382. void ModifiedselectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx) {
  383.  
  384.       int i, j, minIndex, tmp1,tmp2,tmp3;   
  385.  
  386.       for (i = Start_indx; i < End_indx; i++) {
  387.  
  388.             minIndex = i;
  389.  
  390.             for (j = i + 1; j < End_indx+1; j++)
  391.  
  392.                   if (arr[j][indx_to_sort_on] > arr[minIndex][indx_to_sort_on])
  393.  
  394.                         minIndex = j;
  395.  
  396.             if (minIndex != i) {
  397.  
  398.                   tmp1 = arr[i][0];
  399.               tmp2 = arr[i][1];
  400.               tmp3= arr[i][2];
  401.  
  402.                   arr[i][0] = arr[minIndex][0];
  403.               arr[i][1] = arr[minIndex][1];
  404.               arr[i][2] = arr[minIndex][2];
  405.                   arr[minIndex][0] = tmp1;
  406.               arr[minIndex][1] = tmp2;
  407.               arr[minIndex][2] = tmp3;
  408.  
  409.             }
  410.  
  411.       }
  412.  
  413. }
Runtime error #stdin #stdout 0.03s 3308KB
comments (?)
stdin 
3

1 3 140 I

6 8 17 I
1 5 24 C
6 5 26 I
4 8 83 C
6 5 106 C
5 6 118 R
1 4 121 C
7 2 131 I
3 6 153 I
10 7 158 U
4 7 234 I
9 9 294 I

1 1 12 I
2 3 61 C
1 2 105 E
2 1 134 R
2 1 160 C
1 2 171 R
1 2 210 E
2 3 223 I
stdout 
0 0 0

1 2 145
4 1 83
6 1 126
0 0 0
3 0 0
5 0 0
7 0 0
9 0 0
https://ideone.com/Smd2de
language:
C++ (gcc 8.3)
created:
12 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!