BZOJ 1216 操作系统(堆)

用堆模拟题目中的操作即可。

# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <set>
# include <cmath>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define eps 1e-9
# define MOD 1000000000
# define INF 1000000000
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FO(i,a,n) for(int i=a; i<n; ++i)
# define bug puts("H");
# define lch p<<1,l,mid
# define rch p<<1|1,mid+1,r
# define mp make_pair
# define pb push_back
typedef pair<int,int> PII;
typedef vector<int> VI;
# pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;
int Scan() {
    int x=0,f=1;char ch=getchar();
    while(ch<‘0‘||ch>‘9‘){if(ch==‘-‘)f=-1;ch=getchar();}
    while(ch>=‘0‘&&ch<=‘9‘){x=x*10+ch-‘0‘;ch=getchar();}
    return x*f;
}
void Out(int a) {
    if(a<0) {putchar(‘-‘); a=-a;}
    if(a>=10) Out(a/10);
    putchar(a%10+‘0‘);
}
const int N=20005;
//Code begin...

struct node{
    int id, to, t, now, level;
    node(int _id=0, int _to=0, int _t=0, int _level=0):id(_id),to(_to),t(_t),level(_level){}
    bool operator <(const node&r)const{
        if (level!=r.level) return level<r.level;
        return to>r.to;
    }
};
priority_queue<node>que;

int main ()
{
    node tmp;
    int id, to, t, level, f=0;
    while (~scanf("%d%d%d%d",&id,&to,&t,&level)) {
        while (!que.empty()) {
            tmp=que.top(); que.pop();
            if (tmp.t<=to-f) f+=tmp.t, printf("%d %d\n",tmp.id,f);
            else {tmp.t-=(to-f); que.push(tmp); break;}
        }
        f=to;
        que.push(node(id,to,t,level));
    }
    while (!que.empty()) {
        tmp=que.top(); que.pop();
        f+=tmp.t;
        printf("%d %d\n",tmp.id,f);
    }
    return 0;
}

时间: 2024-08-10 19:17:53

BZOJ 1216 操作系统(堆)的相关文章

BZOJ 1216 HNOI 2003 操作系统 堆

题目大意 给出一个CPU处理事件的规则,给出一些事件,问处理这些事件的顺序和结束时间. 思路 我们只需要维护一个堆来模拟他说的规则,之后按顺序输出就行了. CODE #define _CRT_SECURE_NO_WARNINGS #include <queue> #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #define MAX 151

BZOJ 1216: [HNOI2003]操作系统( 优先队列 )

按题意用priority_queue模拟即可 ---------------------------------------------------------------------- #include<bits/stdc++.h> using namespace std; const int maxn = 1009; const int MOD = 10000; struct Node { int x, w, v; bool operator < (const Node &o

BZOJ 1109: [POI2007]堆积木Klo

Sol 排序+树状数组. 我们要找一个满足下列条件的最长序列. \(j-w[j]<=i-w[i],j<i,w[j]<w[i]\) 就是维护一个偏序集的最长上升子序列,然后第一个和第三个式子加起来可以推出第二个式子,然后就是二维偏序,用树状数组来维护就可以了. Code /************************************************************** Problem: 1109 User: BeiYu Language: C++ Result:

BZOJ 1078 斜堆

感谢MATO大神的博客 http://www.cppblog.com/MatoNo1/archive/2013/03/03/192131.html 注意细节. #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #define maxn 150 using namespace std; int n,x,ls[maxn],rs[maxn],fath[maxn],an

BZOJ 1109 POI2007 堆积木Klo LIS

题目大意:给定一个序列,可以多次将某个位置的数删掉并将后面所有数向左串一位,要求操作后a[i]=i的数最多 首先我们假设最后a[i]=i的数的序列为S 那么S满足随着i递增,a[i]递增(相对位置不变),i-a[i]单调不减(后面的不会比前面移动的少) 这是一个三维偏序问题 要是不看题解我就真去写CDQ分治了233 我们发现i=(i-a[i])+a[i] 也就是说如果一个序列满足i-a[i]单调不减且a[i]单调递增 那么i一定单调递增 于是就剩两维偏序了 LIS走起吧= = #include

堆区和栈区的区别

堆和栈的区别一.预备知识—程序的内存分配一个由c/C++编译的程序占用的内存分为以下几个部分1.栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等.其操作方式类似于数据结构中的栈.2.堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 .注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵.3.全局区(静态区)(static)—,全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量

[c++]堆和栈的区别

堆和栈的区别一.预备知识-程序的内存分配一个由c/C++编译的程序占用的内存分为以下几个部分1.栈区(stack)- 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等.其操作方式类似于数据结构中的栈.2.堆区(heap) - 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 .注意它与数据结构中的堆是两回事,分配方式倒是类似于链表,呵呵.3.全局区(静态区)(static)-,全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量

转载:堆和栈的学习

堆和栈的区别一.预备知识—程序的内存分配一个由C/C++编译的程序占用的内存分为以下几个部分1.栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等.其操作方式类似于数据结构中的栈.2.堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 .注意它与数据结构中的堆是两回事,分配方式倒是类似于链表.3.全局区(静态区)(static)—,全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初

浅谈c语言中的堆

操作系统堆管理器管理: 堆管理器是操作系统的一个模块,堆管理内存分配灵活,按需分配. 大块内存: 堆内存管理者总量很大的操作系统内存块,各进程可以按需申请使用,使用完释放. 程序手动申请&释放: 手工意思是需要写代码去申请malloc和释放free. 脏内存: 堆内存也是反复使用的,而且使用者用完释放前不会清除,因此也是脏的. 临时性: 堆内存只在malloc和free之间属于我这个进程,而可以访问.在malloc之前和free之后      都不能再访问,否则会有不可预料的后果. 堆内存使用范