【线段树】【NOI 1999】【cogs 284】内存分配

284. [NOI1999] 内存分配

★★☆   输入文件：memory.in   输出文件：memory.out   简单对比
时间限制：1 s   内存限制：128 MB

内存是计算机重要的资源之一，程序运行的过程中必须对内存进行分配。
经典的内存分配过程是这样进行的：

内存以内存单元为基本单位，每个内存单元用一个固定的整数作为标识，称为地址。地址从0开始连续排列，地址相邻的内存单元被认为是逻辑上连续的。我们把从地址i开始的s个连续的内存单元称为首地址为i长度为s的地址片。
运行过程中有若干进程需要占用内存，对于每个进程有一个申请时刻T，需要内存单元数M及运行时间P。在运行时间P内（即T时刻开始，T+P时刻结束），这M个被占用的内存单元不能再被其他进程使用。

假设在T时刻有一个进程申请M个单元，且运行时间为P，则：
若T时刻内存中存在长度为M的空闲地址片，则系统将这M个空闲单元分配给该进程。若存在多个长度为M个空闲地址片，则系统将首地址最小的那个空闲地址片分配给该进程。

如果T时刻不存在长度为M的空闲地址片，则该进程被放入一个等待队列。对于处于等待队列队头的进程，只要在任一时刻，存在长度为M的空 闲地址片，系统马上将该进程取出队列，并为它分配内存单元。注意，在进行内存分配处理过程中，处于等待队列队头的进程的处理优先级最高，队列中的其它进程 不能先于队头进程被处理。

现在给出一系列描述进程的数据，请编写一程序模拟系统分配内存的过程。

输入

第一行是一个数N，表示总内存单元数（即地址范围从0到N-1）
从第二行开始每行描述一个进程的三个整数T、M、P（M<=N）。
数据已按T从小到大排序。
最后一行用三个0表示结束。
输入文件最多10000行，且所有数据都小于10^9。
输入文件中同一行相邻两项之间用一个或多个空格隔开。

输出

包括2行。
第一行是全部进程都运行完毕的时刻。
第二行是被放入过等待队列的进程总数。

样例输入

10
1 3 10
2 4 3
3 4 4
4 1 4
5 3 4
0 0 0

样例输出
12
2

题解：

可以用线段树维护空序列，然后用平衡树维护一下任务序列就好了。
其实直接用堆维护就可以了，写平衡树各种奇怪问题也是醉了。。
顺便一提：
当年的正解是n^2链表直接暴力模拟，因为当时还没有打标记。。

Code：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<set>
#include<algorithm>
using namespace std;
#define root 1,0,n
#define lch l,mid
#define rch mid+1,r
#define MAXT 0x7ffffffffffffffLL
struct Q{
    long long T;
    int M,P;
}q[10010];
struct QQ{
    int M,P;
}qq[10010];
struct Tree{
    int maxn,lm,rm,lr,rl,lazy;
}tree[4001000];
struct S{
    long long time;
    int l,r;
    bool operator < (const S a) const{
        return time<a.time;
    }
};
multiset<S> a;
int tot=2,ls[4001000],rs[4001000];
int in(){
    int x=0; char ch=getchar();
    while (ch<‘0‘ || ch>‘9‘) ch=getchar();
    while (ch>=‘0‘ && ch<=‘9‘) x=x*10+ch-‘0‘,ch=getchar();
    return x;
}
int New(int l,int r,int p){
    if (p) tree[tot]=(Tree){r-l+1,r-l+1,r-l+1,r,l,-1};
    else tree[tot]=(Tree){0,0,0,l-1,r+1,-1};
    return tot++;
}
void Open(int rt,int l,int r){
    if (!ls[rt]){
        int mid=(l+r)>>1;
        ls[rt]=New(lch,tree[rt].maxn);
        rs[rt]=New(rch,tree[rt].maxn);
    }
}
void paint(int rt,int l,int r,int p){
    if (p) tree[rt]=(Tree){r-l+1,r-l+1,r-l+1,r,l,1};
    else tree[rt]=(Tree){0,0,0,l-1,r+1,0};
}
void push_down(int rt,int l,int r){
    if (tree[rt].lazy!=-1){
        int mid=(l+r)>>1;
        paint(ls[rt],lch,tree[rt].lazy);
        paint(rs[rt],rch,tree[rt].lazy);
        tree[rt].lazy=-1;
    }
}
void change(int rt,int l,int r,int ll,int rr,int k){
    if (ll<=l && r<=rr){
        paint(rt,l,r,k);
        return;
    }
    Open(rt,l,r);
    push_down(rt,l,r);
    int mid=(l+r)>>1;
    if (ll<=mid) change(ls[rt],lch,ll,rr,k);
    if (rr>mid) change(rs[rt],rch,ll,rr,k);
    //lm
    tree[rt].lm=tree[ls[rt]].lm;
    if (tree[ls[rt]].lm==mid-l+1){
        tree[rt].lm+=tree[rs[rt]].lm;
        tree[rt].lr=tree[rs[rt]].lr;
    }
    else tree[rt].lr=tree[ls[rt]].lr;
    //rm
    tree[rt].rm=tree[rs[rt]].rm;
    if (tree[rs[rt]].rm==r-mid){
        tree[rt].rm+=tree[ls[rt]].rm;
        tree[rt].rl=tree[ls[rt]].rl;
    }
    else tree[rt].rl=tree[rs[rt]].rl;
    //maxn
    tree[rt].maxn=max(max(tree[ls[rt]].maxn,tree[rs[rt]].maxn),tree[ls[rt]].rm+tree[rs[rt]].lm);
}
int query(int rt,int l,int r,int k){
    if (l==r) return l;
    Open(rt,l,r);
    push_down(rt,l,r);
    int mid=(l+r)>>1;
    if (tree[ls[rt]].maxn>=k)
        return query(ls[rt],lch,k);
    if (tree[ls[rt]].rm+tree[rs[rt]].lm>=k)
        return tree[ls[rt]].rl;
    return query(rs[rt],rch,k);
}
int main(){
    int n=in(),num=0;
    while (true){
        q[num].T=(long long)in(),q[num].M=in(),q[num].P=in();
        if (!q[num].T && !q[num].M && !q[num].P) break;
        num++;
    }
    if (!num){
        printf("0\n0\n");
        return 0;
    }
    tree[1]=(Tree){n,n,n,n,0,-1}; n--;
    int h=0,t=0,x=0;
    a.insert((S){MAXT,0,0});
    q[num].T=MAXT;
    long long time=-1,ans;
    while (time!=MAXT){
        for (; a.begin()->time==time; a.erase(a.begin()))
            change(root,a.begin()->l,a.begin()->r,1);
        for (; h<t && qq[h].M<=tree[1].maxn; ++h){
            int l=query(root,qq[h].M);
            int r=l+qq[h].M-1;
            change(root,l,r,0);
            a.insert((S){time+qq[h].P,l,r});
        }
        for (; q[x].T==time; ++x)
            if (q[x].M>tree[1].maxn)
                qq[t++]=(QQ){q[x].M,q[x].P};
            else {
                int l=query(root,q[x].M);
                int r=l+q[x].M-1;
                change(root,l,r,0);
                a.insert((S){time+q[x].P,l,r});
            }
        ans=time;
        time=min(a.begin()->time,q[x].T);
    }
    cout<<ans<<endl<<t<<endl;
    return 0;
}