HDU 4288 Coder（线段树）

最新推荐文章于 2017-03-15 18:48:35 发布

glq007

最新推荐文章于 2017-03-15 18:48:35 发布

阅读量769

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：线段树

本文链接：https://blog.youkuaiyun.com/glqac/article/details/40986377

数据结构专栏收录该内容

58 篇文章

订阅专栏

本文提出一种利用离散化与树状数组的数据结构解决方案，针对特定操作问题进行高效处理。通过预处理操作并利用离散化减少排序开销，结合树状数组动态维护数的插入、删除及特定条件下的求和运算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：有三种类型的操作，（1）."add x"，表示往集合里添加数x。（2）.“del x”表示将集合中数x删除。（3）.“sum”求出从小到大排列的集合中下标模5为3的数的和。集合中的数都是唯一的。

YY了半天想出个解法，题目提示数是唯一的这是一个突破口，先读入所有操作离散化，这样插入就不用排序了，然后因为会有删除和添加操作，所以那个下标模5等于3的数是会变化的，有点像个一维DP一样，我就保存下标模5分别等于0，1，2，3，4的sum。

具体一点，如果插入一个数，位置可以通过离散化的map来知道，然后如果往右子树走，那么就走吧走吧～为。。。咳咳，如果往左子树走，那么说明右子树所有的点都要后移一个位置，所以每个点要给一个标记记录后移几个位置，标记是给下面用的，在这次操作右子树的sum得全部右移一个位置～（4的位置当然到0了），标记留在下次往下找的时候更新，算是延迟更新～

删除一个数是类似的～就是向前移一步。

PS：那个标记下传的是后应该是加给子节点。。而不是直接给子节点。。又一次犯这个错误坑了我几个小时找错。。下次一定要注意。

YY的解法效率不够好要跑2S，看了下网上千篇一律的做法发觉的确比我的高明不少，保存区间内有几个数，然后合并就可以根据这个来合并，这样就不用像我那样要移动啊，标记下传啊。。。好是好懒得再写了。。

AC代码：

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<ctype.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<cstdlib>
#include<stack>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#include<ctime>
#include<string.h>
#include<string>
#include<sstream>
#include<bitset>
using namespace std;
#define ll __int64
#define eps 1e-13
#define NMAX 200005
#define MOD 1000000009
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI acos(-1)
template<class T>
inline void scan_d(T &ret)
{
    char c;
    int flag = 0;
    ret=0;
    while(((c=getchar())<'0'||c>'9')&&c!='-');
    if(c == '-')
    {
        flag = 1;
        c = getchar();
    }
    while(c>='0'&&c<='9') ret=ret*10+(c-'0'),c=getchar();
    if(flag) ret = -ret;
}
struct Tree
{
    ll ge,sum[5],flag;
};
Tree T[100005*4];
void pushup(int rt)
{
    for(int i = 0; i < 5; i++)
        T[rt].sum[i] = T[rt<<1].sum[i] + T[rt<<1|1].sum[i];
    T[rt].ge = T[rt<<1].ge + T[rt<<1|1].ge;
}

void build(int l, int r, int rt)
{
    T[rt].ge = T[rt].flag = 0;
    memset(T[rt].sum,0,sizeof(T[rt].sum));
    if(l == r) return;
    int mid = (l+r)>>1;
    build(lson);
    build(rson);
}

void pushdown(int rt)
{
    if(T[rt].flag)
    {
        ll temp[5],c = T[rt].flag;
        if(T[rt<<1].ge)
        {
            T[rt<<1].flag += T[rt].flag;
            for(int i = 0; i < 5; i++)
                temp[(i+c)%5] = T[rt<<1].sum[i];
            memcpy(T[rt<<1].sum,temp,sizeof(temp));
        }
        if(T[rt<<1|1].ge)
        {
            T[rt<<1|1].flag += T[rt].flag;
            for(int i = 0; i < 5; i++)
                temp[(i+c)%5] = T[rt<<1|1].sum[i];
            memcpy(T[rt<<1|1].sum,temp,sizeof(temp));
        }
        T[rt].flag = 0;
    }
}

void updata(int g, int pos, bool k, ll zhi, int l, int r, int rt)
{
    if(l == r)
    {
        if(k)
        {
            T[rt].ge = 1;
            T[rt].sum[(g+1)%5] += zhi;
        }
        else
        {
            T[rt].ge = 0;
            T[rt].sum[(g+1)%5] -= zhi;
        }
        return;
    }
    pushdown(rt);
    int mid = (l+r)>>1;
    if(pos <= mid)
    {
        updata(g,pos,k,zhi,lson);
        int jia = k?1:-1;
        T[rt<<1|1].flag = (T[rt<<1|1].flag+jia+5)%5;
        ll temp[5];
        for(int i = 0; i < 5; i++)
            temp[(i+jia+5)%5] = T[rt<<1|1].sum[i];
        memcpy(T[rt<<1|1].sum,temp,sizeof(temp));
    }
    else updata(g+T[rt<<1].ge,pos,k,zhi,rson);
    pushup(rt);
}

int query[100005],bb[100005];
map<int,int>mp;
int main()
{
#ifdef GLQ
    freopen("input.txt","r",stdin);
//    freopen("o4.txt","w",stdout);
#endif // GLQ
    int n;
    while(~scanf("%d",&n))
    {
        mp.clear();
        int nct = 0;
        char p[5];
        for(int i = 0; i < n; i++)
        {
            scanf("%s",p);
            if(p[0] == 'a')
            {
                scanf("%d",&query[i]);
                bb[nct++] = query[i];
            }
            else if(p[0] == 'd')
            {
                scanf("%d",&query[i]);
                query[i] = -query[i];
            }
            else query[i] = 0;
        }
        sort(bb,bb+nct);
        nct = unique(bb,bb+nct) - bb;
        build(1,nct,1);
        for(int i = 0; i < nct; i++)
            mp[bb[i]] = i+1;
        for(int i = 0; i < n; i++)
        {
            if(query[i] > 0) updata(0,mp[query[i]],1,(ll)query[i],1,nct,1);
            if(query[i] < 0) updata(0,mp[-query[i]],0,(ll)-query[i],1,nct,1);
            if(query[i] == 0)
                printf("%I64d\n",T[1].sum[3]);
        }
    }
    return 0;
}