210 - Concurrency Simulator(WF1991, deque, 模拟）

题目有点长，理解题花了不少时间

粘下别人的翻译~

你的任务是模拟n个程序（按输入顺序编号为1~n）的并行执行。每个程序包含不超过25条语句，格式一共有5种：

　　var=constant（赋值）；

　　print  var（打印）；

　　lock；

　　unlock；

　　end。

变量用单个小写字母表示，初始值为0，为所有程序公有（因此在一个程序里对某个变量赋值可能会影响到另一个程序）。常数是小于100的非负整数。

每个时刻只能有一个程序处于运行态，其他程序均处于等待。上述五种语句分别需要t1、t2、t3、t4、t5单位时间。运行态的程序每次最多运行Q个单位时间（成为配额）。当一个程序的配额用完之后，把当前语句（如果存在）执行完之后该程序会被插入一个等待队列中，然后处理器从队首取出一个程序继续执行。初 始等待队列包含按输入顺序排列的各个程序，但由于lock和unlock语句的出现，这个序列可能会改变。

lock的作用是申请对所有变量的独占访问。lock和unlock总是成对出现，并且不会嵌套。lock总是在unlock的前面。当一个程序成功执行完lock指令后，其他程序一旦试图执行lock指令，就会马上被放到一个所谓的阻止队列的尾部（没有用完的配额就浪费了），当unlock指令执行完毕后，阻止队列的第一个程序进入等待队列的首部。

输入n、t1、t2、t3、t4、t5Q以及n个程序，按照时间顺序输出所有print语句的程序编号和结果。

 

附代码如下：

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<queue>
 #include<cstring>
 #include<deque>
 using namespace std;
 const int maxn = ;
 int n, t1, t2, t3, t4, t5, Q;
 char pro[maxn][];
 int ID[maxn];
 int var[];
 bool locked;
 deque<int>  ReadyQ;
 deque<int>  BlockQ;

 void Run(int id)
 {
     int q = Q;
     while(q > )
     {
         char *ins = pro[ID[id]];
         switch(ins[])
         {
         case '='://var = constant;
             {
                 /*通过数组var进行各变量值的记录*/
                 int buf = ;
                 for(int i = ; i < strlen(ins)-; i++)
                     buf = buf*+(ins[i]-'');
                 var[ins[]-'a'] = buf;
                 q -= t1;
                 break;
             }
         case 'i'://print var;
             {
                 printf("%d: %d\n", id+, var[ins[]-'a']);
                 q -= t2;
                 break;
             }
         case 'c'://lock
             {
                 /*Once a program successfully executes a lock statement, no other program may successfully execute a lock statement
                 until the locking program runs and executes the corresponding unlock statement.
                 Should a running program attempt to execute a lock while one is already in effect,
                 this program will be placed at the end of the blocked queue.*/
                 if(locked)
                 {
                     BlockQ.push_back(id);
                     return;
                 }
                 locked = true;
                 q -= t3;
                 break;
             }
         case 'l'://unlock;
             {
                 locked = false;
                 /*When an unlock is executed, any program at the head of the blocked queue is moved to the head of the ready queue. */
                 if(!BlockQ.empty())
                 {
                     ReadyQ.push_front(BlockQ.front());
                     BlockQ.pop_front();
                 }
                 q -= t4;
                 break;
             }
         case 'd'://end;
             {
                 q -= t5;
                 return;
                 break;
             }
         }//switch;
         ID[id]++;
     }//while;
     /*When a program time quantum expires, another ready program will be selected to run.
     Any instruction currently being executed when the time quantum expires will be allowed to complete. */
     ReadyQ.push_back(id);
 }//Run;

 int main()
 {
     int T;
     scanf("%d", &T);
     for(int cases = ; cases < T; cases++)
     {
         memset(var, , sizeof(var));
         if(cases)   printf("\n");
         scanf("%d%d%d%d%d%d%d", &n, &t1, &t2, &t3, &t4, &t5, &Q);
         int line = ;
         for(int i = ; i < n; i++)
         {
             ///注意记录多行字符串方法
             ///================================================
             fgets(pro[line++], maxn, stdin);
             ID[i] = line-; ///line可记录某ID开始到最后的操作；
                             /*identification number based upon its location in the input data.
                              (the first program has ID = 1, the second has ID = 2, etc.)*/
             while(pro[line-][] != 'd')
                 fgets(pro[line++], maxn, stdin);
             /*Programs are queued first-in-first-out for execution in a ready queue.
             The initial order of the ready queue corresponds to the original order of the programs in the input file.*/
             ///================================================
             ReadyQ.push_back(i);
         }
         locked = false;
         while(!ReadyQ.empty())
         {
             int Pro_id = ReadyQ.front();
             ReadyQ.pop_front();
             Run(Pro_id);
         }
     }
     return ;
 }