27号的十道离线线段树

最新推荐文章于 2024-07-16 10:17:07 发布
最新推荐文章于 2024-07-16 10:17:07 发布
阅读量90 收藏
点赞数
原文链接：http://www.cnblogs.com/--560/p/4762060.html
版权

27号的十道离线线段树

hdu4288: (2012成都网络赛&&cf)

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

const int maxn=1000100;
const int INF=(1<<29);

typedef long long ll;
int N;
char op[maxn][10];
int Q[maxn];
int X[maxn],Xn;
struct Node
{
    int cnt;
    ll sum[5];
};Node T[maxn<<2];

void push_up(int rt)
{
    T[rt].cnt=T[rt<<1].cnt+T[rt<<1|1].cnt;
    for(int i=0;i<5;i++){
        T[rt].sum[i]=T[rt<<1].sum[i]+T[rt<<1|1].sum[(i-T[rt<<1].cnt+50000000)%5];
    }
}

void build(int l,int r,int rt)
{
    if(l>r) return;
    if(l==r){
        T[rt].cnt=0;
        for(int i=0;i<5;i++) T[rt].sum[i]=0;
        return;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int pos,int val,int op,int l,int r,int rt)
{
    if(l==r){
        if(op==1){
            if(T[rt].cnt==1) return;
        }
        if(op==-1){
            if(T[rt].cnt==0) return;
        }
        T[rt].cnt+=op;
        T[rt].sum[1]+=val;
        return;
    }
    int m=(l+r)>>1;
    if(pos<=m) update(pos,val,op,lson);
    else update(pos,val,op,rson);
    push_up(rt);
}

void get(int l,int r,int rt)
{
    cout<<"rt="<<rt<<" l="<<l<<" r="<<r<<" cnt="<<T[rt].cnt<<endl;
    if(l==r) return;
    int m=(l+r)>>1;
    get(lson);
    get(rson);
    return;
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(cin>>N){
        Xn=0;
        for(int i=1;i<=N;i++){
            scanf("%s",op[i]);
            if(op[i][0]!='s'){
                scanf("%d",&Q[i]);
                X[++Xn]=Q[i];
            }
        }
        sort(X+1,X+Xn+1);
        Xn=unique(X+1,X+Xn+1)-(X+1);
        build(1,Xn,1);
        for(int i=1;i<=N;i++){
            int pos=lower_bound(X+1,X+Xn+1,Q[i])-X;
            if(op[i][0]=='a') update(pos,Q[i],1,1,Xn,1);
            else if(op[i][0]=='d') update(pos,-Q[i],-1,1,Xn,1);
            else printf("%I64d\n",T[1].sum[3]);
        }
    }
    return 0;
}
View Code

 hdu5200(bestcoder#36 C)

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

const int maxn=50100;
const int INF=(1<<29);
typedef long long ll;

ll N,Q;
int H;
struct Tree
{
    ll h;
    ll id;
    friend bool operator<(Tree A,Tree B)
    {
        return A.h<B.h;
    }
};Tree tree[maxn];int tn;
struct Query
{
    int ask;
    int ans;
    ll id;
    friend bool operator<(Query A,Query B)
    {
        return A.ask<B.ask;
    }
};Query q[maxn];
struct Node
{
    ll lsum,rsum,sum;
};Node T[maxn<<2];

bool cmp(Query A,Query B)
{
    return A.id<B.id;
}

void push_up(int rt,int m)
{
    T[rt].sum=T[rt<<1].sum+T[rt<<1|1].sum;
    T[rt].lsum=T[rt<<1].lsum;
    T[rt].rsum=T[rt<<1|1].rsum;
    if(T[rt].lsum==(m-(m>>1))) T[rt].lsum+=T[rt<<1|1].lsum;
    if(T[rt].rsum==(m>>1)) T[rt].rsum+=T[rt<<1].rsum;
    if(T[rt<<1].rsum&&T[rt<<1|1].lsum) T[rt].sum--;
}

void build(int l,int r,int rt)
{
    if(l==r){
        T[rt].sum=T[rt].lsum=T[rt].rsum=1;
        return;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt,r-l+1);
}

void update(int pos,int l,int r,int rt)
{
    if(l==r){
        T[rt].lsum=T[rt].rsum=T[rt].sum=0;
        return;
    }
    int m=(l+r)>>1;
    if(pos<=m) update(pos,lson);
    else update(pos,rson);
    push_up(rt,r-l+1);
}

int main()
{
    freopen("in.txt","r",stdin);
    while(cin>>N>>Q){
        tn=0;
        for(int i=1;i<=N;i++){
            scanf("%d",&H);
            tree[++tn].h=H;
            tree[tn].id=i;
        }
        sort(tree+1,tree+tn+1);
        for(int i=1;i<=Q;i++){
            scanf("%d",&q[i].ask);
            q[i].id=i;
        }
        sort(q+1,q+Q+1);
        build(1,N,1);
        int tot=1;
        for(int i=1;i<=Q;i++){
            while(tree[tot].h<=q[i].ask&&tot<=N){
                update(tree[tot].id,1,N,1);
                tot++;
            }
            q[i].ans=T[1].sum;
        }
        sort(q+1,q+Q+1,cmp);
        for(int i=1;i<=Q;i++){
            printf("%d\n",q[i].ans);
        }
    }
    return 0;
}
View Code

 xdoj1114(Orz_Panda A题)

#include<bits/stdc++.h>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

const int maxn=1000100;

int N,Q;
struct Panda
{
    int val,id;
    friend bool operator<(Panda A,Panda B)
    {
        return A.val<B.val;
    }
};Panda A[maxn];
struct Query
{
    int l,r,k1,k2,id;
    int cnt1,cnt2;
    friend bool operator<(Query A,Query B)
    {
        return A.id<B.id;
    }
};Query q[maxn];
struct Node
{
    int cnt;
};Node T[maxn<<2];

bool cmp1(Query A,Query B)
{
    return A.k1<B.k1;
}

bool cmp2(Query A,Query B)
{
    return A.k2>B.k2;
}

void push_up(int rt)
{
    T[rt].cnt=T[rt<<1].cnt+T[rt<<1|1].cnt;
}

void build(int l,int r,int rt)
{
    if(l==r){
        T[rt].cnt=0;
        return;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int pos,int l,int r,int rt)
{
    if(l==r){
        T[rt].cnt=1;
        return;
    }
    int m=(l+r)>>1;
    if(pos<=m) update(pos,lson);
    else update(pos,rson);
    push_up(rt);
}

int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return T[rt].cnt;
    int m=(l+r)>>1;
    int res=0;
    if(L<=m) res+=query(L,R,lson);
    if(R>m) res+=query(L,R,rson);
    return res;
}

int main()
{
    freopen("in.txt","r",stdin);
    while(cin>>N>>Q){
        for(int i=1;i<=N;i++){
            scanf("%d",&A[i].val);
            A[i].id=i;
        }
        sort(A+1,A+N+1);
        build(1,N,1);
        for(int i=1;i<=Q;i++){
            scanf("%d%d%d%d",&q[i].l,&q[i].r,&q[i].k1,&q[i].k2);
            q[i].id=i;
        }
        sort(q+1,q+Q+1,cmp1);
        int tot=1;
        for(int i=1;i<=Q;i++){
            while(A[tot].val<q[i].k1&&tot<=N) update(A[tot++].id,1,N,1);
            q[i].cnt1=query(q[i].l,q[i].r,1,N,1);
        }
        sort(q+1,q+Q+1,cmp2);
        build(1,N,1);
        tot=N;
        for(int i=1;i<=Q;i++){
            while(A[tot].val>q[i].k2&&tot>=1) update(A[tot--].id,1,N,1);
            q[i].cnt2=query(q[i].l,q[i].r,1,N,1);
        }
        sort(q+1,q+Q+1);
        for(int i=1;i<=Q;i++){
            printf("%d\n",q[i].r-q[i].l+1-q[i].cnt1-q[i].cnt2);
        }
    }
    return 0;
}
View Code

 hdu4417(2012杭州网络赛 水题)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

typedef long long ll;
const int maxn=1000100;

int N,Q;
struct Brick
{
    ll h;
    int id;
    friend bool operator<(Brick A,Brick B)
    {
        return A.h<B.h;
    }
};Brick A[maxn];
struct Query
{
    int l,r;
    ll h;
    int id,ans;
    friend bool operator<(Query A,Query B)
    {
        return A.h<B.h;
    }
};Query q[maxn];
int cnt[maxn<<2];

bool cmp(Query A,Query B)
{
    return A.id<B.id;
}

void push_up(int rt)
{
    cnt[rt]=cnt[rt<<1]+cnt[rt<<1|1];
}

void build(int l,int r,int rt)
{
    if(l==r){
        cnt[rt]=0;
        return;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt);
}

void update(int pos,int l,int r,int rt)
{
    if(l==r){
        cnt[rt]=1;
        return;
    }
    int m=(l+r)>>1;
    if(pos<=m) update(pos,lson);
    else update(pos,rson);
    push_up(rt);
}

int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return cnt[rt];
    int m=(l+r)>>1;
    int res=0;
    if(L<=m) res+=query(L,R,lson);
    if(R>m) res+=query(L,R,rson);
    return res;
}

int main()
{
    freopen("in.txt","r",stdin);
    int T;cin>>T;
    int casen=1;
    while(T--){
        scanf("%d%d",&N,&Q);
        for(int i=1;i<=N;i++){
            scanf("%I64d",&A[i].h);
            A[i].id=i;
        }
        sort(A+1,A+N+1);
        build(1,N,1);
        for(int i=1;i<=Q;i++){
            scanf("%d%d%I64d",&q[i].l,&q[i].r,&q[i].h);
            q[i].l++;q[i].r++;
            q[i].id=i;
        }
        sort(q+1,q+Q+1);
        int tot=1;
        for(int i=1;i<=Q;i++){
            while(tot<=N&&A[tot].h<=q[i].h) update(A[tot++].id,1,N,1);
            q[i].ans=query(q[i].l,q[i].r,1,N,1);
        }
        sort(q+1,q+Q+1,cmp);
        printf("Case %d:\n",casen++);
        for(int i=1;i<=Q;i++){
            printf("%d\n",q[i].ans);
        }
    }
    return 0;
}
View Code

 codeforces 482B 涉及位运算&和|

#include<bits/stdc++.h>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

using namespace std;

const int maxn=1000100;

typedef long long ll;
int N,Q;
ll val[maxn<<2];
struct Query
{
    int l,r;
    ll ask;
};Query q[maxn];

void push_up(int rt)
{
    val[rt]=val[rt<<1]&val[rt<<1|1];
}

void push_down(int rt)
{
    val[rt<<1]|=val[rt];
    val[rt<<1|1]|=val[rt];
}

void update(int L,int R,ll c,int l,int r,int rt)
{
    if(L<=l&&r<=R){
        val[rt]|=c;
        return;
    }
    push_down(rt);
    int m=(l+r)>>1;
    if(L<=m) update(L,R,c,lson);
    if(R>m) update(L,R,c,rson);
    push_up(rt);
}

ll query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return val[rt];
    push_down(rt);
    int m=(l+r)>>1;
    ll res=(1LL<<60)-1;
    if(L<=m) res&=query(L,R,lson);
    if(R>m) res&=query(L,R,rson);
    push_up(rt);
    return res;
}

void get(int l,int r,int rt)
{
    if(l==r){
        printf("%I64d ",val[rt]);
        return;
    }
    push_down(rt);
    int m=(l+r)>>1;
    get(lson);
    get(rson);
    push_up(rt);
}

int main()
{
    //freopen("in.txt","r",stdin);
    while(cin>>N>>Q){
        memset(val,0,sizeof(val));
        for(int i=1;i<=Q;i++){
            scanf("%d%d%I64d",&q[i].l,&q[i].r,&q[i].ask);
            update(q[i].l,q[i].r,q[i].ask,1,N,1);
        }
        bool flag=1;
        for(int i=1;i<=Q;i++){
            if(query(q[i].l,q[i].r,1,N,1)!=q[i].ask){
                flag=0;break;
            }
        }
        if(flag){
            puts("YES");
            get(1,N,1);
            puts("");
        }
        else puts("NO");
    }
    return 0;
}
View Code

 

转载于:https://www.cnblogs.com/--560/p/4762060.html

weixin_30507481
关注
线段树离线处理专题
衬衫的价格是九磅十五便士是不是很熟悉？
07-27 1098
如果说算法是程序的灵魂，那么数据结构是程序的肉体。掌握基本的数据结构，并且能灵活运用这些数据结构，是信息学竞赛中常用的一些招法。在竞赛中，学会这种数据结构在当今的比赛中已经处于落伍地位，如何运用这些数据结构处理问题，才是我们需要掌握的真正本领。        在阅读以下的知识时候，博主默认各位朋友已经了解并且能合理使用线段树进行相应的增删改查操作，这些知识网上很多（推荐NotOnlySucces
计算机体系结构的一些总结
tugouxp的专栏
02-05 1223
广义上来说，按照不同层次的授权等级，可把芯片IP分类为指令集、IP核、芯片架构等。如果说指令集是一本“字典”，那么IP核提供了“段落”的写作方式，芯片架构则可被视作是“整篇文章的提纲”。芯片IP企业作为芯片设计企业的上游供应商，通常以授权的方式，向后者收取专利费用。而芯片设计企业通过购买不同层级的IP授权，可以设计出不同自研程度的芯片产品。
SPOJ - DQUERY D-query —— 线段树 离线处理
Lngxling的博客
08-28 259
DQUERY - D-query #sorting #tree   English Vietnamese Given a sequence of n numbers a1, a2, ..., an and a number of d-queries. A d-query is a pair (i, j) (1 ≤ i ≤ j ≤ n). For each d-query (i, j...
HDU 3333 线段树 离线处理
天际苍穹的博客
07-16 184
Turing Tree Time Limit: 6000/3000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7869Accepted Submission(s): 2862 Problem Descri...
离线处理，线段树，区间求和-线段树
Landing_on_Mars的博客
09-05 89
每组数据，第一行为n，表示这个整数序列长为n（1
HDU 4638 线段树离线操作
samscream的博客
07-24 114
#include<bits/stdc++.h> using namespace std; const int maxn=1e5+10; int a[maxn]; struct node{ int l,r,v; }tree[maxn<<2]; struct pp{ int l,r,id; }po[maxn]; int pre[maxn],ans[maxn];...
WHUT第八周训练整理
月巴虫丰博客
02-10 1192
WHUT第八周（并查集+最小生成树）训练整理
学习笔记(OI)
qq_43589598的博客
12-06 403
虽迟但到 #1.树上问题 这东西一直是我的弱项所以从它开始。 1.树的直径 指树上最长的链。 首先随便找个点DFS找到距离这个点最远的点，然后以这个点为起点DFS找对距离它最远的点，这两个点之间的路径就是树的直径 code： const int N = 10000 + 10; int n, c, d[N]; vector<int> E[N]; void dfs(int u, int fa) { for (int v : E[u]) { if (v == fa) continue
OI做题总结
最新发布
dingxingdi的博客
07-16 868
数学竞赛蓝书上与OI/ICPC有关内容也可阅读OI考前注意事项见川外团队骗分导论见腾讯微云。
【刷题计划1】【poj分类转载】
loving coding
08-19 1251
----------------2018.4.10更新-----------------------原本这只是暑假刷题计划，后来因为某些原因，自己就不是很努力的刷题，现在情况有变，so，重新继续咯~下个月26号省赛，扣去中间实训的一周时间和几次校赛，大概只有一个月时间。目前计划是，每天基础算法题+cf上3题，专业课也先停了，自己这段时间只想认真写题。昨天晚上又失眠了，虽然我知道保证训练效率的关键是...
hdu 3333 线段树离线操作
pcfbyssz的博客
08-20 212
hdu 3333 线段树离线操作     题目大意：求解区间内不同数字的和 显然，要先按照查询区间的右值进行排序。然后进行数据插入，把每个数放进线段树的时候，先判断再之前他有没有在线段树，如果在，则删除它，并把他的位置更新到当前点。 #include&lt;stdio.h&gt;   #include&lt;string.h&gt;   #include&lt;algorithm&gt...
HDU 3333 线段树强制离线处理
小菜鸟。。
05-11 454
http://acm.hdu.edu.cn/showproblem.php?pid=3333 作为一个萌新第一次遇到这种题是很绝望的，大佬的姿势真多！！！ 题意：n个数字，m次查询，求每次查询区间数的和（重复的只算一遍） 思路：如果是在线处理要T，只能强制离线（来自大佬的一句话）            1.将m次询问一次性读入，按右端点从小到大排序，如果右端点一样，那左端点
HDU4630 线段树离线操作 && GCD性质
samscream的博客
07-15 247
题意： n个数，m个询问，每次查询一个区间的中任意两个数的最大GCD 思路： 离线操作，按照查询的右端点将查询从小到大排序。预处理出所有数的因子用二维vector保存。遍历整个这n个数，每个数遍历它的因子，如果这个因子在前面出现过，则将这个因子维护到线段树中，并将因子最新出现位更新，如果没有出现过则将当前此因子最新出现的位置标记为当前。线段树用来维护区间的最大因子。因为区间两次以上出现过的最...
运用时间线段树对树上问题进行离线处理
zhangtingxiqwq的博客
08-24 59
对于树上问题，有时候离线处理更优，但要维护操作之间的有序性，可以考虑用时间线段树维护。
HDU 3333 线段树+离线处理
Dan__ge的博客
06-12 2996
点击打开链接 题意：问你给定区间内的不重复的数字的和，如1 1 1 3 4 ，区间1到2就是1，区间1到5就是8 思路：这种线段树只能离线来写，离线的方法是按照查询区间的右端点来排序，然后这道题目的数据范围较大需要离散化简单处理一下，然后对于输入的每个点来说，顺序走下去，然后如果当前点之前出现过，便将之前的删除然后把现在的添加线段树中，为什么这么可以，看了网上神犇一句话，那就是对于要查询的区间
HDU 4288 Coder（线段树＋离线处理）
To be excellent！
07-13 1060
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4288 维护一个序列an，有以下三种操作： 一、在序列中添加元素x 二、在序列中删除元素x 三、计算序列中下标i%5=3的元素和 在写解题报告之前先废话几句关于线段树的姿势问题： 之前一直习惯于结构体姿势的线段树，后来看了notonlysuccess的线段树总结，开始采用数组
HDU 4417 【线段树+离线处理】
a6334167的博客
07-13 165
http://acm.hdu.edu.cn/showproblem.php?pid=4417 题意：找出给定区间内，有多少个数小于等于给定的数。用线段树维护的话会超时，要用到线段树的离线操作，对询问与数列都进行从小到大的排序，记录下标。从第一个询问开始，遍历数列，满足小于等于就插入到线段树中相应的位置。答案即为当前线段树中有多少个值。转换成了区间和，记录答案，最后一遍输出。 代码如下...
hdu4417 线段树+离线处理
zxf654073270的专栏
11-03 606
简单线段树+离线处理
hdu 3333 Turing Tree（线段树+离线操作）（莫队+离散化）
daydreamer23333的博客
07-09 137
https://vjudge.net/contest/381909#problem/L 菜鸡第一篇博客 准备记录一下暑训训练。 题目思路：因为题目要求不相同的数的值，在线复杂度太高，所以离线处理查询。先以查询的末尾为标准，将储存查询数据的结构体从小到大排序。 然后从前往后更新线段树叶子结点，用map记录数值出现的最近位置，不断更新，然后边更新边查询，这样将之前的数值清零并不会影响到后面的操作。 还有记得开ll 具体操作见代码： #include <stdio.h> #include <i
线段树详解与应用
"线段树基础" 线段树是一种数据结构，主要用于处理区间或段上的数据查询和更新操作，常用于解决动态区间统计问题。它是由二叉树结构实现的，每个节点代表一个特定的区间，而这个区间在树的不同层级被不断细分。线段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值