NOI2004 郁闷的出纳员

最新推荐文章于 2024-07-08 16:46:10 发布
最新推荐文章于 2024-07-08 16:46:10 发布
阅读量707 收藏
点赞数
分类专栏： ACM-数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ivan_zjj/article/details/8657034
版权

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1503

题意：给出N中操作，分别是I（往一列数中增加一个数）、A（将数列中的现有数全部加上一个数）、S（将数列中的所有数全部都减去一个数，如果某个数的值小于给定的MIN，这个数就会被彻底地删除）、F（询问数列中现有数中的第K大数）。

思路：应用高级数据结构解题，可以用线段树、树状数组、或者平衡树。

线段树：

#include <stdio.h>
#include <string.h>
#include <algorithm>
int N ,M ;
const int len = 17 ;
const int base = 1 << len ;
const int NN = 3 * base ;

int sum[ NN << 2 ]  ;
int ss[ NN << 2 ] ;

void down(int l , int r , int idx){
    if( ss[idx] ){
        ss[idx<<1] = ss[idx<<1|1] = 1 ;
        ss[idx] = 0 ;
        sum[idx<<1] = sum[idx<<1|1] = 0 ;
        return ;
    }
}

void update(int l ,int r, int idx , int pos , int v ){
    if( l == r ){
        sum[idx] += v ;
        return ;
    }
    int mid = (l + r) >> 1 ;
    down( l ,r , idx) ;
    if( pos <= mid )    update( l ,mid , idx<<1 ,pos , v ) ;
    else                update( mid+1 ,r , idx<<1|1 , pos , v ) ;
    sum[idx] = sum[idx<<1] + sum[idx<<1|1] ;
}

int set(int l ,int r, int a, int b , int idx){
    if( l==a && r==b ){
        int res = sum[idx] ;
        sum[idx] = 0 ; ss[idx] = 1 ;
        return res ;
    }
    int mid = (l + r) >> 1 ;
    down( l ,r , idx ) ;
    int ret = 0 ;
    if( b<=mid )    ret = set(l , mid , a ,b , idx<<1) ;
    else if( a > mid )  ret = set( mid+1 , r , a , b, idx<<1|1) ;
    else{
        ret = set(l , mid , a , mid , idx<<1) ;
        ret += set(mid+1 ,r , mid+1, b, idx<<1|1 ) ;
    }
    sum[idx] = sum[idx<<1] + sum[idx<<1|1] ;
    return ret ;
}

int query(int l ,int r , int idx, int cnt ){
    if( l == r ){
        return l ;
    }
    int mid = ( l + r ) >> 1 ;
    down( l ,r , idx) ;
    if( sum[idx<<1] >= cnt )    return query( l , mid , idx<<1 , cnt ) ;
    else                        return query( mid+1 , r , idx<<1|1 , cnt - sum[idx<<1] )  ;
}

int main(){
    char ch[3] ; int a ;
    while( scanf("%d %d",&N,&M) == 2 ){
        memset( sum , 0 ,sizeof(sum) );
        memset( ss , 0 ,sizeof(ss) )  ;

        int del = 0 , ans = 0 , tot = 0 ;
        for(int i=0;i<N;i++){
            scanf("%s%d",ch,&a);
            if( ch[0] == 'I' ){
                if( a < M ) continue ;
                a = a + base - del ; tot++ ;
                update(1 , NN , 1 , a , 1 ) ;
            }
            else if( ch[0] == 'S' ){
                /*
                这里还有一种思路：就是枚举将要被删除的员工的工资，如果某个工资
                的人数不为0就用log（n）的时间在线段树中将其删除。
                这里主要说明一下为什么可以直接枚举工资：这是因为每次工资的变动
                最多就只有1000，假设在本次S之前的del为d1 ,本次S之后的del为d2,则有
                d1 > d2 ;那么在本次S之前，0 -- Min-1-dl这个区间肯定已经被“清零”了，
                而本次S之后的目的就是将0 -- Min-1-d2“清零”；那么也就是:
                [ Min-1-d1 , Min-1-d2 ] ， 这个区间最大也就是工资的最大变动值，也就是
                1000 ，而S最多也就是100，这样最多就是100000*log(n)，是不会超时的。
                */
                del -= a ;
                int aa = set(1, NN , 1 , base+M-1-del , 1) ;
                ans += aa ; tot -= aa ;
            }
            else if( ch[0] == 'A' ){
                del += a ;
            }
            else{   // 'F'
                if( tot < a ){
                    printf("-1\n");
                }
                else
                    printf("%d\n", query(1 , NN , 1 , tot - a + 1 ) - base + del );
            }
        }
        printf("%d\n",ans );
    }
    return 0 ;
}


树状数组：

#include <stdio.h>
#include <string.h>

const int BB = 100000 ;
const int LL = BB * 3 ;
int N , M ;
int out , tot ,del ;
int sum[ LL ] ;

int lowbit( int n ){ return n&(n^(n-1)) ; }

void insert_into( int n ,int v){
    while( n < LL ){
        sum[n] += v ;
        n += lowbit(n) ;
    }
}

void insert(int a){
    if( a < M ) return ;
    insert_into( a - del + BB , 1 ) ;
    tot++ ;
}

void add(int a){
    del += a ;
}

void sub( int ori ,int now ){
    int s,  e ;
    s = M - 1 + BB - ori ;
    e = M - 1 + BB - now ;
    for(int i=s;i<=e;i++){
        if( sum[i] > 0 ){
            tot -= sum[i] ;
            out += sum[i] ;
            insert_into( i , -sum[i] ) ;
        }
    }
}

void subtract(int a){
    sub( del , del - a ) ;
    del -= a ;
}

int search(int n){
    int ans = 0 ;
    while( n >= 1 ){
        ans += sum[n] ;
        n -= lowbit(n) ;
    }
    return ans ;
}

int query( int n ){
    int low = 1 , high = LL - 1 , mid ;
    while( low < high ){
        mid = (low + high) >> 1 ;
        int cnt = search( mid ) ;
        if(  cnt >= n ) high = mid ;
        else            low = mid + 1 ;
    }
    return low + del - BB ;
}

void find( int a ){
    if( a > tot ){
        printf("-1\n");
        return ;
    }
    a = tot + 1 - a ;
    printf("%d\n",query(a) );
}
int main(){
    char ch[4] ; int a ;
    while( scanf("%d%d",&N,&M) == 2 ){
        memset( sum , 0 , sizeof(sum) ) ;
        out = tot = del = 0 ;
        for(int i=0;i<N;i++){
            scanf("%s %d",ch,&a);
            switch( ch[0] ){
                case 'I' :  insert(a);  break ;
                case 'A' :  add(a);     break ;
                case 'S' :  subtract(a);break ;
                case 'F' :  find(a);    break ;
            }
        }
        printf("%d\n",out);
    }
    return 0 ;
}

AVL树： 

#include <stdio.h>
#include <string.h>
#include <map>

const int NN = 100010 ;
int N , M ;
int del , tot, ans ,ncnt ;
std::map<int,int> mp ;

struct Node{
    int height ;
    struct Node *left, *right ;
    int size ;
    int value ;
    int num ;
    void init( int _v ){
        value = _v ;
        height = 0 ; size = 1 ;
        num = 1 ;
        left = right = NULL ;
    }
}p[NN];
typedef Node* pnode ;
pnode T ;

int calc_hei( pnode T ){
    if( T==NULL )   return -1;
    else            return T->height ;
}
int calc_size( pnode T ){
    if( T==NULL )   return 0 ;
    else            return T->size ;
}
int calc_num( pnode T ){
    if( T==NULL )   return 0 ;
    else            return T->num ;
}
pnode RotateLeft( pnode T ){
    pnode k = T->left ;
    T->left = k->right ;
    k->right = T ;
    T->height = std::max( calc_hei(T->left) , calc_hei(T->right) ) + 1 ;
    T->size = calc_size( T->left ) + calc_size( T->right ) + calc_num(T) ;
    k->height = std::max( calc_hei(k->left) , calc_hei(k->right) ) + 1 ;
    k->size = calc_size( k->left ) + calc_size( k->right ) + calc_num(k);
    return k ;
}

pnode RotateRight( pnode T ){
    pnode k = T->right ;
    T->right = k->left ;
    k->left = T ;
    T->height = std::max( calc_hei(T->left) , calc_hei(T->right) ) + 1 ;
    T->size = calc_size( T->left ) + calc_size( T->right ) + calc_num(T) ;
    k->height = std::max( calc_hei(k->left) , calc_hei(k->right) ) + 1 ;
    k->size = calc_size( k->left ) + calc_size( k->right ) + calc_num(k);
    return k ;
}

pnode insert( pnode T , int a ){
    if( T==NULL ){
        T = &p[ncnt++] ;
        T->init( a ) ;
        return T ;
    }
    if( T->value == a ){
        T->size++ ; T->num++ ;
        return T ;
    }
    else if( a < T->value ){
        //左
        T->left = insert( T->left , a ) ;
        if( calc_hei(T->left) - calc_hei(T->right) == 2 ){
            if( a < T->left->value ){
                T = RotateLeft( T ) ;
            }
            else{
                T->left = RotateRight( T->left );
                T = RotateLeft( T ) ;
            }
        }
    }
    else{
        //右
        T->right = insert( T->right , a ) ;
        if( calc_hei(T->right) - calc_hei(T->left) == 2 ){
            if( a < T->right->value ){
                T->right = RotateLeft( T->right ) ;
                T = RotateRight( T ) ;
            }
            else
                T = RotateRight( T ) ;
        }
    }
    T->height = std::max( calc_hei(T->left) , calc_hei(T->right) ) + 1 ;
    T->size = calc_size( T->left ) + calc_size( T->right ) + calc_num( T ) ;
    return T ;
}

pnode move(pnode, int) ;

pnode out( pnode T ){
    if( T->left!=NULL && T->right!=NULL ){
        pnode tmp = T->right ;
        while( tmp->left != NULL ) tmp = tmp->left ;
        T->value = tmp->value ;
        T->num = tmp->num ;
        T->right = move( T->right , T->value ) ;
        T->size = calc_size( T->left ) + calc_size( T->right ) + calc_num(T) ;
        T->height = std::max( calc_hei( T->left ) , calc_hei( T->right ) ) + 1 ;
        return T ;
    }
    else{
        if( T->left == NULL ){
            T = T->right ;
            return T ;
        }
        else{
            T = T->left ;
            return T ;
        }
    }
}

pnode move( pnode T , int a ){
    if( T==NULL )   return NULL ;
    if( T->value == a ){
        T = out( T ) ;
        return T ;
    }
    if( a < T->value ){
        T->left = move( T->left , a ) ;
        if( calc_hei(T->right) - calc_hei(T->left) == 2 )
            if( T->right->left!=NULL && calc_hei(T->right->left) > calc_hei(T->right->right) ){
                T->right = RotateLeft( T->right ) ;
                T = RotateRight( T ) ;
            }
            else
                T = RotateRight( T ) ;
    }
    else{
        T->right = move( T->right , a ) ;
        if( calc_hei(T->left) - calc_hei(T->right) == 2 )
            if( T->left->right!=NULL && calc_hei(T->left->right) > calc_hei(T->left->left) ){
                T->left = RotateRight( T->left ) ;
                T = RotateLeft( T ) ;
            }
            else
                T = RotateLeft( T ) ;
    }
    if( T==NULL )   return NULL ;
    T->size = calc_size( T->left ) + calc_size( T->right ) + calc_num(T) ;
    T->height = std::max( calc_hei( T->left ) , calc_hei( T->right ) ) + 1 ;
    return T ;
}

void deal(int s,  int e ){
    for(int i=M-1-s;i<=M-1-e;++i){
        if( mp[i] == 0 )    continue ;
        tot -= mp[i] ; ans += mp[i] ; mp[i] = 0 ;
        T = move( T , i ) ;
    }
}

int search( pnode T  , int a ){
    int cc = T->num ;
    if( calc_size(T->left) >= a-cc && calc_size(T->left)<=a-1 ){
        return T->value ;
    }
    if( calc_size(T->left) < a-cc ){
         return search( T->right , a-calc_size(T->left)-cc  ) ;
    }
    else{
        return search( T->left ,a ) ;
    }
}

void output( int a ){
    if( a > tot ){
        printf("-1\n"); return ;
    }
    a = tot + 1 - a ;
    printf("%d\n",search(T , a) + del ) ;
}
int main(){
    char ch[4] ; int a ;
    T = NULL ;
    while( scanf("%d%d",&N,&M) == 2 ){
        int cas = 0 ;
        del = tot = ans = 0 ; mp.clear() ; ncnt = 0 ;
        for(int i=0;i<N;++i){
            scanf("%s%d",ch,&a);
            switch( ch[0] ){
                case 'I' :
                    if( a >= M ){
                        tot++ ;
                        a = a - del ;
                        mp[a]++ ;
                        T = insert(T , a) ;
                    }
                    break ;
                case 'A' :
                    del += a ;
                    break ;
                case 'S' :
                    deal( del ,del-a ) ;
                    del -= a ;
                    break ;
                case 'F' :
                    output( a ) ;
                    break ;
            }
        }
        printf("%d\n",ans);
    }
    return 0 ;
}

SBT树： 

#include <stdio.h>
#include <string.h>
const int NN = 100010 ;
int left[NN] , right[NN] , size[NN] , key[NN] ;
int T , node , del , leave , N , M ;

void left_rotate(int &T){
    int k = right[T] ;
    right[T] = left[k] ;
    left[k] = T ;
    size[k] = size[T] ;
    size[T] = size[ left[T] ] + size[right[T]] + 1 ;
    T = k ;
}
void right_rotate(int &T){
    int k = left[T] ;
    left[T] = right[k] ;
    right[k] = T ;
    size[k] = size[T] ;
    size[T] = size[left[T]] + size[right[T]] + 1 ;
    T = k ;
}
void add(int &T, int v){
    T = ++node ;
    left[T] = right[T] = 0;
    size[T] = 1 ;key[T] = v ;
}
void Maintain(int &T,int flag){
    if( flag == 0 ){
        if( size[left[left[T]]] > size[right[T]] )
            right_rotate( T ) ;
        else if( size[right[left[T]]] > size[right[T]] )
            left_rotate( left[T] ) , right_rotate( T ) ;
        else
            return ;
    }
    else{
        if( size[right[right[T]]] > size[left[T]] )
            left_rotate(T);
        else if( size[left[right[T]]] > size[left[T]] )
            right_rotate( right[T] ) , left_rotate( T ) ;
        else
            return ;
    }
    Maintain( left[T] , 0 ) ;
    Maintain( right[T] , 1 ) ;
    Maintain( T , 0 ) ;
    Maintain( T , 1 ) ;
}
void insert(int &T,int v){
    if( T == 0 ){
        add( T , v ) ;
        return ;
    }
    size[T]++ ;
    if( v < key[T] )
        insert( left[T] , v ) ;
    else
        insert( right[T] , v ) ;
    Maintain( T , v >= key[T] ) ;
}
int erase(int &T,int v){
    if(T == 0)  return 0 ;
    int n ;
    if( v < key[T] ){
        n = erase( left[T] , v )  ;
        size[T] -= n ;
    }
    else{
        n = size[ left[T] ] + 1 + erase( right[T] , v ) ;
        T = right[T] ;
    }
}
int query(int &T,int n){
    int k = size[ left[T] ] + 1 ;
    if( n == k )    return  key[T] ;
    if( n < k )     return  query( left[T]  , n ) ;
    else            return  query( right[T] , n - k ) ;
}

int main(){
    char ch[5] ; int a ;
    while( scanf("%d%d",&N,&M)==2 ){
        del = T = leave = node = size[0] = left[0] = right[0] = 0 ;
        for(int i=0;i<N;i++){
            scanf("%s%d",ch,&a);
            if( ch[0]=='I' ){
                if( a >= M )
                    insert( T ,a - del ) ;
            }
            else if( ch[0] == 'A' ){
                del += a;
            }
            else if( ch[0] == 'S' ){
                del -= a ;
                leave += erase( T , M-1-del ) ;
            }
            else{
                if( a > size[T] )
                    printf("-1\n");
                else
                    printf("%d\n",query(T,size[T]+1-a)+del );
            }
        }
        printf("%d\n",leave);
    }
    return 0 ;
}


「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOI2004测试数据
09-13
【标题】"NOI2004测试数据" 指的是全国青少年信息学奥林匹克（National Olympiad in Informatics, NOI）2004年的竞赛所使用的测试数据集。NOI是中国最高级别的青少年编程竞赛，旨在提升青少年的信息技术素养和算法...
NOI大纲NOI大纲NOI大纲.pdf
04-08
根据提供的信息，我们可以了解到这份文档主要涉及的是NOI（全国信息学奥林匹克竞赛）的大纲内容。由于实际的大纲内容没有给出，以下将基于NOI、信奥（信息学奥林匹克）、C++等关键词展开相关的知识点介绍。 ### 1. ...
noi题库答案 c语言,NOIP2004提高组复赛试题答案c语言版
weixin_34931142的博客
05-18 261
该楼层疑似违规已被系统折叠隐藏此楼查看此楼boolfinish,hash[256],used[27];intn,stk[27];stringa,b,c;stringword;voidinit(){fin>>n>>a>>b>>c;finish=false;}voidoutsol(){inti,ans[...
NOI2004郁闷的出纳员
04-19 536
每个数字的值是tr[k].num+delta
P1486 [NOI2004] 郁闷的出纳员 题解
lv_jia_qi的博客
05-26 149
P1486 [NOI2004] 郁闷的出纳员 题解
NOI 2004 郁闷的出纳员
我要吃熊猫
04-06 312
splay
[NOI2004]郁闷的出纳员
C202044zxy的博客
11-27 163
一、题目 点此看题 二、解法 这道题很新的一点就是加工资和减工资，这貌似要用到区间修改。 但是细细想想，操作的对象是全树，我们可以维护一个累积的修改值，新加入一个点的话要删去之前的累计的修改值，对于减工资的情况，判断有没有低于最低的限制。 注意如果一个一来人就低于最低线，那么这个人不被统计在最后的删除人数中。 #include <cstdio> #include <iostrea...
BZOJ 1503 [NOI2004]郁闷的出纳员
sdfzrlt的博客
04-06 291
treap
洛谷 P1486 [NOI2004] 郁闷的出纳员（splay）
最新发布
weixin_74174531的博客
07-08 439
这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。工资的频繁调整很让员工反感，尤其是集体扣除工资的时候，一旦某位员工发现自己的工资已经低于了合同规定的工资下界，他就会立刻气愤地离开公司，并且再也不会回来了。对于2,3两种情况，我们设置一个变量delta，每次涨薪，降薪的时候我们都在deltag上操作，那么每个节点的当前价值加上delta就是实际价值，每次降薪之后，我们需要找到>=min-delta的最小值的工资的节点，然后把这个节点之前的所有节点都删除（不包括L节点）。
NOI2004 郁闷的出纳员 [Splay]
weixin_30887919的博客
07-19 105
题目描述 OIER公司是一家大型专业化软件公司，有着数以万计的员工。作为一名出纳员，我的任务之一便是统计每位员工的工资。这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。如果他心情好，就可能把每位员工的工资加上一个相同的量。反之，如果心情不好，就可能把他们的工资扣除一个相同的量。我真不知道除了调工资他还做什么其它事情。 工资的频繁调整很让员工反感，尤其是集...
BZOJ1503 NOI2004 郁闷的出纳员 平衡树
a18700013354的博客
02-26 108
题意：开始时给定一个空的数列，要求维护：1、加入一个数 2、数列中所有元素+k 3、数列中所有元素-k 4、查询数列中的第k大。其中对于任意时刻，如果有一个元素＜Min，则删除该元素。 题解：平衡树裸题……话说当年还打算把Splay Treap SBT都学一下，结果现在只会Splay了QAQ #include <cstdio> #include <c...
NOI2021Day2.pdf
08-06
### 全国青少年信息学奥林匹克竞赛（NOI2021）知识点总结 #### 题目描述与相关概念 在第38届全国青少年信息学奥林匹克竞赛（NOI2021）的第二试中，包含了多道信息学题目。题目描述了多个实际应用领域中的问题，例如...
NOI 2021 统一省选
04-16
【NOI 2021 统一省选】是中国计算机学会（CCF）组织的一场重要的编程竞赛，旨在选拔优秀的青少年参加国际信息学奥林匹克竞赛（IOI）。这个活动为广大学子提供了一个展示和提升自己算法设计与编程能力的平台，同时也...
NOI 2005-2009试题
03-29
全国信息学奥林匹克竞赛（National Olympiad in Informatics, NOI）是中国最高级别的中学生信息学竞赛，每年举办一次，旨在选拔优秀的青少年参加国际信息学奥林匹克竞赛（IOI）。"NOI 2005-2009试题"的资源包含了这...
HDU_4125 Moles 线段树
Chris_Home
09-04 984
http://acm.hdu.edu.cn/showproblem.php?pid=4125 题意： 给你N个数字，先按照给数的顺序建一棵二叉查找树，然后按中序遍历树的结点，并记录访问结点的奇偶顺序，这样就会得到一个序列，再给你一个0,1序列，现在要你求给出的序列在遍历出来的序列中出现的次数，序列允许相互覆盖。 思路： 暴力建树如果二叉树退化成一个树链的话，时间复杂度就会变成O(N^2)，
POJ 2104 K-th Number 划分树
Chris_Home
04-10 962
http://poj.org/problem?id=2104 题意：给定N个数的数组，求Q次询问的区间第K小的数。 思路：用划分树求解。所谓的划分树，说白了就是线段树的一种扩展，在划分树中，树的每个结点还是表示一个区间，假设是(l,r)，只不过和线段树不同的是划分树对每个结点还维护一个数组，数组的长度为区间的长度（即：(r-l+1)）。然后我们就是对区间进行划分，划分的依据就是找到一种“基准元
HDU_3255 Farming 扫描线求面积并
Chris_Home
07-12 899
http://acm.hdu.edu.cn/showproblem.php?pid=3255 题意： 有N块农田，每块农田中种一种作物，每种作物都有一个价格，当在同一区域内种植了两种不同的作物时，作物价格大的生存下来，生命值小的死亡。求最后的所有作物的能买的总钱数。 思路： 扫描线求体积并，和前面的一个求体积交差不多。 我们可以将作物的价格看作是立体的高，这样就可以直接枚举Z轴求二维矩形面
POJ_2482 Stars in Your Window 扫描线 + 线段树
Chris_Home
07-12 881
http://poj.org/problem?id=2482 题意： 给你一个二维坐标系，和其中的一些点，这些点每个都有一个自己的value，要求用一个W*H的矩形框 框住尽可能多的点，并且使得被包括的点的values和最大。 思路： 和黑书上的一道例题类似，我们可以先将所有的点分成两个点，一个是原来的点(x,y,v) ，再加一个点（x+W,y,-v），然后将所有的点按照X排序，（这样做的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值