UVA 210 Concurrency Simulator

题目链接：https://vjudge.net/problem/UVA-210

题目大意

　　一共有 T 组案例。

　　对于每组案例，你的任务是模拟n个程序（按输入顺序编号1~n）的并行执行。每个程序包含不超过25条语句。

　　格式一共是5种：赋值（var=constant），打印（print var），lock，unlock，end，耗时分别为$t_1,t_2,t_3,t_4,t_5$​。

　　变量用一个小写字母表示，初始时为0，为所有并行程序共有，且它的值始终保持在[0,100]内，所以一个程序对某一个变量的赋值会影响到另外一个程序。

　　每个时刻只能是一个程序处于运行状态，其他程序处于等待状态。运行状态之中的的程序每次最多分配Q个单位时间，一旦在未执行完某个程序的某个指令时超过分配时间，则执行完那个指令后，这个程序会被插入等待队列，然后从其的队首取出一个程序继续执行。而初始的等待队列为按照输入程序排入。

　　但是由于lock和unlock命令的出现，这个顺序会被改变。

　　lock的作用是申请对所有变量的独占访问，unlock则是解除对所有变量的独占访问，且它们一定成对出现。当一个程序已经对所有的变量独占访问后，其他程序若试图执行lock，无论其是否耗尽分配时间，都会被放在一个阻止队列的尾部，且当那个程序解除的时候，则会从阻止队列的头部的程序进入等待队列的头部。

　　现在给出$n,t_1,t_2,t_3,t_4,t_5,Q$以及n个程序，你需要输出所有print命令执行输出的值。

　　每组案例的输出结果之间空一行。

　　翻译搬运自洛谷。

分析

　　并行程序模拟，不难，细心即可。

代码如下

#include <bits/stdc++.h>
using namespace std;
 
#define INIT() ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define Rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define rFor(i,t,s) for (int i = (t); i >= (s); --i)
#define ForLL(i, s, t) for (LL i = LL(s); i <= LL(t); ++i)
#define rForLL(i, t, s) for (LL i = LL(t); i >= LL(s); --i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
#define rforeach(i,c) for (__typeof(c.rbegin()) i = c.rbegin(); i != c.rend(); ++i)
 
#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
 
#define LOWBIT(x) ((x)&(-x))
 
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
 
#define ms0(a) memset(a,0,sizeof(a))
#define msI(a) memset(a,inf,sizeof(a))
#define msM(a) memset(a,-1,sizeof(a))

#define MP make_pair
#define PB push_back
#define ft first
#define sd second
 
template<typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
    in >> p.first >> p.second;
    return in;
}
 
template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
    for (auto &x: v)
        in >> x;
    return in;
}
 
template<typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
    out << "[" << p.first << ", " << p.second << "]" << "
";
    return out;
}

inline int gc(){
    static const int BUF = 1e7;
    static char buf[BUF], *bg = buf + BUF, *ed = bg;
    
    if(bg == ed) fread(bg = buf, 1, BUF, stdin);
    return *bg++;
} 

inline int ri(){
    int x = 0, f = 1, c = gc();
    for(; c<48||c>57; f = c=='-'?-1:f, c=gc());
    for(; c>47&&c<58; x = x*10 + c - 48, c=gc());
    return x*f;
}
 
typedef long long LL;
typedef unsigned long long uLL;
typedef pair< double, double > PDD;
typedef pair< int, int > PII;
typedef pair< int, PII > PIPII;
typedef pair< string, int > PSI;
typedef pair< int, PSI > PIPSI;
typedef set< int > SI;
typedef vector< int > VI;
typedef vector< VI > VVI;
typedef vector< PII > VPII;
typedef map< int, int > MII;
typedef map< string, int > MSI;
typedef multimap< int, int > MMII;
typedef unordered_map< int, int > uMII;
typedef pair< LL, LL > PLL;
typedef vector< LL > VL;
typedef vector< VL > VVL;
typedef priority_queue< int > PQIMax;
typedef priority_queue< int, VI, greater< int > > PQIMin;
const double EPS = 1e-10;
const LL inf = 0x7fffffff;
const LL infLL = 0x7fffffffffffffffLL;
const LL mod = 1e9 + 7;
const int maxN = 1e5 + 7;
const LL ONE = 1;
const LL evenBits = 0xaaaaaaaaaaaaaaaa;
const LL oddBits = 0x5555555555555555;

struct Instruction{
    queue< PIPSI > ins;
}IS[37];
int len;

int n, t[6], Q, T; 
deque< int > waitQ; // 等待队列 
queue< int > blockQ; // 阻塞队列 
MSI vars; // 存储变量映射 
bool islock; // 当前是否有锁 

void solve() {
    while(!waitQ.empty()) {
        int nowM = waitQ.front();
        waitQ.pop_front();
        
        int tmp = 0;
        queue< PIPSI > &tmpIS = IS[nowM].ins;  // 当前指令队列 
        while(tmp < Q && !tmpIS.empty()) {
            PIPSI inst = tmpIS.front();
            tmp += t[inst.ft];
            
            switch(inst.ft) {
                case 1:{
                    vars[inst.sd.ft] = inst.sd.sd;
                    break;
                }
                case 2:{
                    cout << nowM << ": " << vars[inst.sd.ft] << endl;
                    break;
                }
                case 3:{
                    if(islock) {
                        blockQ.push(nowM);
                        tmp = inf;
                    }
                    else islock = true;
                    break;
                }
                case 4:{
                    islock = false;
                    if(!blockQ.empty()) {
                        waitQ.push_front(blockQ.front());
                        blockQ.pop();
                    }
                    break;
                }
                case 5: break;
            }
            if(tmp != inf) tmpIS.pop();    
        }
        if(!tmpIS.empty() && tmp != inf) waitQ.PB(nowM);
    }
}

int main(){
    //freopen("MyOutput.txt","w",stdout);
    INIT();
    cin >> T;
    while(T--) {
        cin >> n;
        For(i, 1, 5) cin >> t[i];
        cin >> Q;
        len = 0;
        vars.clear();
        
        For(i, 1, n) {
            string tmp;
            queue< PIPSI > &tmpIS = IS[++len].ins;
            waitQ.PB(len);
            
            while(cin >> tmp) {
                if(tmp == "end") {
                    tmpIS.push(MP(5, MP("", -1)));
                    break;
                }
                else if(tmp == "print") {
                    cin >> tmp;
                    tmpIS.push(MP(2, MP(tmp, -1)));
                }
                else if(tmp == "lock") tmpIS.push(MP(3, MP("", -1)));
                else if(tmp == "unlock") tmpIS.push(MP(4, MP("", -1)));
                else {
                    string tt;
                    int x;
                    cin >> tt >> x;
                    tmpIS.push(MP(1, MP(tmp, x)));
                }
            }    
        }
        solve();
        if(T) cout << endl;
    }
    return 0;
}