HDU 4553 约会安排

Posted 2020-12-25 zgqblogs

　　　　　　　　　　约会安排

　　　　　　　　Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
　　　　　　　　Total Submission(s): 2637    Accepted Submission(s): 732
　　

Problem Description

　　寒假来了，又到了小明和女神们约会的季节。
　　小明虽为屌丝级码农，但非常活跃，女神们常常在小明网上的大段发言后热情回复“呵呵”，所以，小明的最爱就是和女神们约会。与此同时，也有很多基友找他开黑，由于数量实在过于巨大，怎么安排时间便成了小明的一大心事。
　　我们已知小明一共有T的空闲时间，期间会有很多女神或者基友来找小明。
　　作为一个操作系统曾经怒考71分的大神，小明想到了一个算法，即“首次适应算法”，根据操作系统课本的描述，就是找一段最靠前的符合要求的连续空间分配给每个请求，由此小明做出了一个决定：
　　当一个基友来找小明时，小明就根据“首次适应算法”来找一段空闲的时间来和基友约好，如果找到，就说“X,let’s fly”（此处，X为开始时间），否则就说“fly with yourself”；
　　当女神来找小明时，先使用一次“首次适应算法”，如果没有找到，小明就冒着木叽叽的风险无视所有屌丝基友的约定，再次使用“无视基友首次适应算法”，两次只要有一次找到，就说“X,don’t put my gezi”（此处，X为开始时间），否则就说“wait for me”
　　当然，我们知道小明不是一个节操负无穷的人，如果和女神约会完，还有剩余时间，他还是会和原来约好的基友去dota的。（举个例子：小西（屌丝）和小明约好在1~5这个时间单位段内打dota，这时候，女神来和小明预约长度为3的时间段，那么最终就是1~3小明去和女神约会，搞定后在4~5和小西打dota）
　　小明偶尔也会想要学习新知识，此时小明就会把某一个时间区间的所有已经预定的时间全部清空用来学习并且怒吼“I am the hope of chinese chengxuyuan!!”，不过小明一般都是三分钟热度，再有人来预定的话，小明就会按耐不住寂寞把学习新知识的时间分配出去。

 

 

Input

输入第一行为CASE，表示有CASE组测试数据；
每组数据以两个整数T，N开始，T代表总共的时间，N表示预约请求的个数；
接着的N行，每行表示一个女神或者基友的预约，“NS QT”代表一个女神来找小明约一段长为QT的时间，“DS QT”则代表一个屌丝的长为QT的请求，当然也有可能是小明想学知识了，“STUDY!! L R”代表清空L~R区间内的所有请求。

[Technical Specification]
1. 1 <= CASE <= 30
2. 1 <= T, N <= 100000
3. 1 <= QT <= 110000
4. 1 <= L <= R <=T

 

 

Output

对于每一个case，第一行先输出“Case C:”代表是第几个case，然后N行，每行对应一个请求的结果(参照描述)。
输出样本(可复制此处)：
“X,let‘s fly”,”fly with yourself”,”X,don‘t put my gezi”,”wait for me”,”I am the hope of chinese chengxuyuan!!”

 

 

Sample Input

1 5 6 DS 3 NS 2 NS 4 STUDY!! 1 5 DS 4 NS 2

 

 

Sample Output

Case 1: 1,let‘s fly 4,don‘t put my gezi wait for me I am the hope of chinese chengxuyuan!! 1,let‘s fly 1,don‘t put my gezi

 

 

思路

此题线段树

线段树的区间更新，这是我做的第二题，第一题是POJ的 Tunnel Warfare,不过这题我并没有按照线段树写，所以或许这题是我写的第一题。

我的代码并不毒瘤，相信你看我的代码很容易可以看懂，不过我还是说一下树的一些细节吧。

树的节点里面，存的是，当前区间，从左端点开始数起，有时间的长度，以及从右端点开始数，以及这个区间里面，最长的连续区间。

女神和屌丝的时间要分开储存，屌丝发来邀请，女神的时间不受影响，而女神发来邀请，屌丝的时间也没有了，这是在是太毒瘤了。

其他的细节确实比较多，看代码可以很清楚的了解这些细节。

 

在线段树里面，还有一些我实在是想不通的细节，其实是我还没有去想，这导致了我不断地wrong answer，这个点就是在此题的，我的代码里面的82行，110行，在我看来，这个地方完全不需要push_down，因为这里更新只后，在查询到这里时，就会自动push_down，emmmm等一下，我好像突然明白了什么。

 

在更新之时，可能在下一次查询到来之前，再次迎来更新，而此次更新时在这个节点的下方，如果这里没有push_down,那么这里的状态就不会改变，如果下次查询查到这里，向下更新的的过程之中，就会改变原来更新的值。。。。

这好像也不是很对，总之这种情况我不知遇到一次了。

刚刚py大佬对我说，线段树只要不写崩，一般是不会tle的，可是我却经常tle，或许是我太菜了，常数天大，也或许是我滥用push_down，这个东西对我来说，用多了会就tle，用少了就会wrong answer ，每一次提交都不知道离ac有多么遥远，作为一名菜鸡，我的心灵实在是受不了这样的折磨

代码

 

#include<iostream>
#include<algorithm>
#define ls t<<1
#define rs (t<<1)|1
using namespace std;
struct node
{
    int l,r;
    int ll,ml,rl;
    int llx,mlx,rlx;
}tree[100086*4];

void build(int t,int l,int r)
{
    tree[t].l=l;
    tree[t].r=r;
    tree[t].ll=tree[t].rl=tree[t].ml=r-l+1;
    tree[t].llx=tree[t].rlx=tree[t].mlx=r-l+1;
    if(l==r){return;}
    int mid=(l+r)>>1;

    build(ls,l,mid);
    build(rs,mid+1,r);
}

void push_down(int t)
{
    if(tree[t].l==tree[t].r)return;

    if(tree[t].ml==0){
        tree[ls].ml=tree[ls].ll=tree[ls].rl=0;
        tree[rs].ml=tree[rs].ll=tree[rs].rl=0;
    }
    if(tree[t].ml==tree[t].r-tree[t].l+1)
    {
        tree[ls].ml=tree[ls].ll=tree[ls].rl=tree[ls].r-tree[ls].l+1;
        tree[rs].ml=tree[rs].ll=tree[rs].rl=tree[rs].r-tree[rs].l+1;
    }

    if(tree[t].mlx==0){
        tree[ls].mlx=tree[ls].llx=tree[ls].rlx=0;
        tree[rs].mlx=tree[rs].llx=tree[rs].rlx=0;
    }
    if(tree[t].mlx==tree[t].r-tree[t].l+1)
    {
        tree[ls].mlx=tree[ls].llx=tree[ls].rlx=tree[ls].r-tree[ls].l+1;
        tree[rs].mlx=tree[rs].llx=tree[rs].rlx=tree[rs].r-tree[rs].l+1;
    }


}


int query1(int t,int x)
{
    push_down(t);
    if(tree[t].ml<x){return -1;}
    if(tree[t].ll>=x){return tree[t].l;}
    if(tree[ls].ml>=x){return query1(ls,x);}
    if(tree[ls].rl+tree[rs].ll>=x){return tree[ls].r-tree[ls].rl+1;}
    if(tree[rs].ml>=x){return query1(rs,x);}
    if(tree[rs].rl>=x){return tree[rs].r-tree[rs].rl+1;}
}

int query2(int t,int x)
{
    push_down(t);
    if(tree[t].mlx<x){return -1;}
    if(tree[t].llx>=x){return tree[t].l;}
    if(tree[ls].mlx>=x){return query2(ls,x);}
    if(tree[ls].rlx+tree[rs].llx>=x){return tree[ls].r-tree[ls].rlx+1;}
    if(tree[rs].mlx>=x){return query2(rs,x);}
    if(tree[rs].rlx>=x){return tree[rs].r-tree[rs].rlx+1;}
}

void update1(int t,int l,int r,int num)//来自屌丝的更新。不影响女神树
{
    if(tree[t].l==l&&tree[t].r==r){
        tree[t].ll=tree[t].rl=tree[t].ml=(tree[t].r-tree[t].l+1)*num;
        return;
    }
    push_down(t);
    int mid=(tree[t].l+tree[t].r)>>1;
    if(r<=mid){update1(ls,l,r,num);}
    else if(l>mid){update1(rs,l,r,num);}
    else{
        update1(ls,l,mid,num);
        update1(rs,mid+1,r,num);
    }

    tree[t].ll=tree[ls].ll;
    tree[t].rl=tree[rs].rl;
    tree[t].ml=max(tree[ls].ml,tree[rs].ml);
    tree[t].ml=max(tree[t].ml,tree[ls].rl+tree[rs].ll);
    if(tree[ls].ll==tree[ls].r-tree[ls].l+1){
        tree[t].ll=tree[ls].ll+tree[rs].ll;
    }
    if(tree[rs].rl==tree[rs].r-tree[rs].l+1){
        tree[t].rl=tree[rs].rl+tree[ls].rl;
    }
}

void update2(int t,int l,int r,int num)//来自女神的更新
{
    if(tree[t].l==l&&tree[t].r==r){
        tree[t].ll=tree[t].rl=tree[t].ml=(tree[t].r-tree[t].l+1)*num;
        tree[t].llx=tree[t].rlx=tree[t].mlx=(tree[t].r-tree[t].l+1)*num;
        return;
    }
    push_down(t);
    int mid=(tree[t].l+tree[t].r)>>1;
    if(r<=mid){update2(ls,l,r,num);}
    else if(l>mid){update2(rs,l,r,num);}
    else{
        update2(ls,l,mid,num);
        update2(rs,mid+1,r,num);
    }

    tree[t].ll=tree[ls].ll;
    tree[t].rl=tree[rs].rl;
    tree[t].ml=max(tree[ls].ml,tree[rs].ml);
    tree[t].ml=max(tree[t].ml,tree[ls].rl+tree[rs].ll);
    if(tree[ls].ll==tree[ls].r-tree[ls].l+1){
        tree[t].ll=tree[ls].ll+tree[rs].ll;
    }
    if(tree[rs].rl==tree[rs].r-tree[rs].l+1){
        tree[t].rl=tree[ls].rl+tree[rs].rl;
    }

    tree[t].llx=tree[ls].llx;
    tree[t].rlx=tree[rs].rlx;
    tree[t].mlx=max(tree[ls].mlx,tree[rs].mlx);
    tree[t].mlx=max(tree[t].mlx,tree[ls].rlx+tree[rs].llx);
    if(tree[ls].llx==tree[ls].r-tree[ls].l+1){
        tree[t].llx=tree[ls].llx+tree[rs].llx;
    }
    if(tree[rs].rlx==tree[rs].r-tree[rs].l+1){
        tree[t].rlx=tree[rs].rlx+tree[ls].rlx;
    }
}

void view_tree()
{
    for(int i=1;i<=10;i++){
        printf("
%d: %d %d
",i,tree[i].l,tree[i].r);
        printf("%d %d %d
",tree[i].ll,tree[i].rl,tree[i].ml);
        printf("%d %d %d
",tree[i].llx,tree[i].rlx,tree[i].mlx);
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    int sst=1;
    while(T--){
        printf("Case %d:
",sst++);
        int n,m,ans,tm;
        scanf("%d%d",&n,&m);
        char s[10];
        build(1,1,n);
        for(int i=1;i<=m;i++){
            scanf("%s",s);
            if(s[0]==‘N‘){
                scanf("%d",&tm);
                ans=query1(1,tm);
                if(ans==-1){
                    ans=query2(1,tm);
                    if(ans==-1){
                        printf("wait for me
");
                    }
                    else{
                        printf("%d,don‘t put my gezi
",ans);
                        update2(1,ans,ans+tm-1,0);
                    }
                }
                else{
                    printf("%d,don‘t put my gezi
",ans);
                    update2(1,ans,ans+tm-1,0);
                }

            }
            if(s[0]==‘D‘){
                scanf("%d",&tm);
                ans=query1(1,tm);
                if(ans==-1){printf("fly with yourself
");}
                else {printf("%d,let‘s fly
",ans);
                    update1(1,ans,ans+tm-1,0);
                }
            }
            if(s[0]==‘S‘){
                int x,y;
                scanf("%d%d",&x,&y);
                update2(1,x,y,1);
                printf("I am the hope of chinese chengxuyuan!!
");
            }
        }
    }
}

　　As the last ship sailed towards the distant horizon,I sat there watching on a rock.My mind slowly drifting away,froming into my Dreamtale.