210 - Concurrency Simulator【模拟、双端队列】

没有什么特别的,就是按照题意进行模拟,代码有点长。。。

#include<cstdio>
#include<queue>
#include<map>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 222;
int n,t[10],q;
int Value[maxn];
/*
    1   a = 1
    2   print
    3   lock
    4   unlock
    5   end
*/
struct Data{
    int kind;
    int aim;
    int value;
    Data(int x,int y,int z = 0){
        kind = x;
        aim  = y;
        value= z;
    }
};
struct Pro{
    vector<Data>q;
    int now;
}arr[maxn];
deque<int>dq;
queue<int>eq;
void debug(){
    for(int i = 0; i < n; i++){
        printf("[%d]\n",i);
        for(int j = 0; j < arr[i].q.size(); j++)
            printf("%d %c %d\n",arr[i].q[j].kind,arr[i].q[j].aim,arr[i].q[j].value);
    }
}
void solve(){
    dq.clear();
    while(!eq.empty()) eq.pop();
    for(int i = 0; i < n; i++)
        dq.push_back(i);
    int islock = 0;
    while(!dq.empty()){
        int time = 0,i;         //记录这个当前程序运行的时间
        int now = dq.front();
        dq.pop_front();
        int have_finish = 0;
        for(; arr[now].now < arr[now].q.size() && time < q; arr[now].now ++ ){
            i = arr[now].now;
            int kind = arr[now].q[i].kind;
            //printf("-> %d %d %d\n",now,i,kind);
            if(kind == 1){
                int aim = arr[now].q[i].aim;
                int value = arr[now].q[i].value;
                Value[aim] = value;
            }
            else if(kind == 2){
                int aim = arr[now].q[i].aim;
                printf("%d: %d\n",now + 1,Value[aim]);
            }
            else if(kind == 3){ //锁住
                if(!islock){    //没有锁住

                }
                else{
                    eq.push(now);
                    have_finish = 1;
                    break;
                }
                islock ++;
            }
            else if(kind == 4){
                islock --;
                if(!eq.empty()){
                    dq.push_front(eq.front());
                    eq.pop();
                }
            }
            else if(kind == 5){
                have_finish = 1;
                break;
            }
            time += t[kind];
        }
        if(!have_finish){
            dq.push_back(now);
        }

    }
}
int main(){
    int T;
    //printf("%d\n",'z');
    scanf("%d",&T);
    while(T--){
        memset(Value,0,sizeof(Value));
        scanf("%d",&n);
        for(int i = 1; i <= 5; i++)
            scanf("%d",&t[i]);
        scanf("%d",&q);
        for(int i = 0; i < n; i++){
            char str[maxn];
            arr[i].now = 0;
            arr[i].q.clear();
            while(true){
                scanf("%s",str);
                if(!strcmp(str,"end")){
                    arr[i].q.push_back(Data(5,0));
                    break;
                }
                else if(!strcmp(str,"print")){
                    scanf("%s",str);
                    arr[i].q.push_back(Data(2,str[0]));
                }
                else if(!strcmp(str,"lock")){
                    arr[i].q.push_back(Data(3,0));
                }
                else if(!strcmp(str,"unlock")){
                    arr[i].q.push_back(Data(4,0));
                }
                else{
                    int value;
                    scanf("%*s%d",&value);
                    arr[i].q.push_back(Data(1,str[0],value));
                }
            }
        }
        //debug();
        solve();
        if(T) printf("\n");
    }
    return 0;
}
时间: 2024-09-29 18:56:38

210 - Concurrency Simulator【模拟、双端队列】的相关文章

列表VS双端队列

双端队列支持线程安全,在两端任何一端执行添加和删除,时间复杂度为o(1).访问两端的索引访问,时间复杂度为o(1).访问中间元素时间复杂度为o(n).随机访问还是采用列表 列表:时间复杂度为o(n) 双端队列的实现:class Deque:# 模拟双端队列def __init__(self):self.items = []def isEmpty(self):return self.items == []def addFront(self,item):self.items.append(item)

[程序员代码面试指南]栈和队列-生成窗口最大值数组(双端队列)

问题描述 输入数组arr={4,3,5,4,3,3,6,7},窗口大小w=3,窗口由左向右移动,输出每个窗口最大值组成的数组. 解题思路 数据结构:使用ArrayList模拟双端队列. 遍历一遍arr,时间复杂度O(n).具体地, 队列队尾的位置对应的元素若不比当前位置对应元素大,则弹出,否则,将当前元素入队. -每次检查队首元素下标是否已超出以当前位置为结尾的窗口,超出则出队. 代码 import java.util.LinkedList; public class Main { public

UVa 210 Concurrency Simulator (双端队列+模拟)

题意:给定n个程序,每种程序有五种操作,分别为 var = constant(赋值),print var (打印), lock, unlock,end. 变量用小写字母表示,初始化为0,为程序所公有(一个程序里对某个变量修改可以会影响其他程序里的这个变量), 常数小于100(也就是说最多两位数). 每个时刻都只能有一个程序处于运行状态,其他的都在等待,上述五种操作用时分别是t1, t2, t3, t4, t5.运行中的程序, 每次最多能运行q个时间,当q个时间被用完后,它会被放在等待队列的尾部,

UVa 210 Concurrency Simulator(双端队列)

题意  模拟程序并行运行 STL队列 双端队列 的应用  用双端队列维护即将执行的程序  再用个队列维护等待变量释放的程序   用lock表示变量锁定状态 先将所有程序依次放到执行队列中  每次取出队首程序运行不超过lim时间  未运行完又放到执行队列队尾 遇到lock时  若当前锁定状态为false就将锁定状态变为true  否则将当前程序放到等待队列队尾并结束运行 遇到unlock时  若等待队列有程序  就将等待队列队首程序放到执行队列队首 遇到end时 退出当前执行(不再进队尾) #in

hdu-5929 Basic Data Structure(双端队列+模拟)

题目链接: Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 207    Accepted Submission(s): 41 Problem Description Mr. Frog learned a basic data structure recently, which is called

【BZOJ2457】[BeiJing2011]双端队列 贪心+模拟

[BZOJ2457][BeiJing2011]双端队列 Description Sherry现在碰到了一个棘手的问题,有N个整数需要排序. Sherry手头能用的工具就是若干个双端队列. 她需要依次处理这N个数,对于每个数,Sherry能做以下两件事: 1.新建一个双端队列,并将当前数作为这个队列中的唯一的数: 2.将当前数放入已有的队列的头之前或者尾之后. 对所有的数处理完成之后,Sherry将这些队列排序后就可以得到一个非降的序列. Input 第一行包含一个整数N,表示整数的个数.接下来的

【SGU】271. Book Pile(双端队列模拟)

一摞书,2个操作,一个操作是在书堆上加一本,第二个将前K个书翻转 看别人用Splay树做的,但是可以用双端队列模拟,因为K个书之后的书位置已经定下来了,所以只需要记录在队列头加书还是尾加书 #include<cstdio> #include<string> #include<algorithm> #include<queue> #include<stack> #include<cstring> #include<iostream

Java 模拟队列(一般队列、双端队列、优先级队列)

队列: 先进先出,处理类似排队的问题,先排的.先处理,后排的等前面的处理完了,再处理 对于插入和移除操作的时间复杂度都为O(1).从后面插入,从前面移除 双端队列: 即在队列两端都能够insert和remove:insertLeft.insertRight.removeLeft.removeRight 含有栈和队列的功能,如去掉insertLeft.removeLeft,那就跟栈一样了.如去掉insertLeft.removeRight.那就跟队列一样了 一般使用频率较低,时间复杂度 O(1)

补番计划 (长沙理工大学第十一届程序设计竞赛)(双端队列+set容器+string)

补番计划 Time Limit : 4000/2000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other) Total Submission(s) : 8   Accepted Submission(s) : 1 Font: Times New Roman | Verdana | Georgia Font Size: ← → Problem Description 阿聪是一个日漫狂魔.暑假在家的时候,他有12小时在补番,12小时在睡

lintcode 二叉树的锯齿形层次遍历 (双端队列)

题目链接: http://www.lintcode.com/zh-cn/problem/binary-tree-zigzag-level-order-traversal/ 二叉树的锯齿形层次遍历 给出一棵二叉树,返回其节点值的锯齿形层次遍历(先从左往右,下一层再从右往左,层与层之间交替进行) 样例 给出一棵二叉树 {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 返回其锯齿形的层次遍历为: [ [3], [20,9], [15,7] ] 思路: 我们用双端队列模拟一下这个过程