bzoj3295[Cqoi2011]动态逆序对（cdq分治||可持久化线段树）

最新推荐文章于 2018-12-27 19:46:45 发布
最新推荐文章于 2018-12-27 19:46:45 发布
阅读量403 收藏 1
点赞数
分类专栏： 数据结构 主席树 其他 cdq分治 文章标签： 可持久化线段树 主席树 cdq分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014325920/article/details/51245827
版权

题目链接：点这里！！！


3295: [Cqoi2011]动态逆序对

Time Limit: 10 Sec   Memory Limit: 128 MB
Submit: 3043   Solved: 967
[ Submit][ Status][ Discuss]

Description

对于序列A，它的逆序对数定义为满足i<j，且Ai>Aj的数对(i,j)的个数。给1到n的一个排列，按照某种顺序依次删除m个元素，你的任务是在每次删除一个元素之前统计整个序列的逆序对数。

Input

输入第一行包含两个整数n和m，即初始元素的个数和删除的元素个数。以下n行每行包含一个1到n之间的正整数，即初始排列。以下m行每行一个正整数，依次为每次删除的元素。
 

Output

 
输出包含m行，依次为删除每个元素之前，逆序对的个数。

Sample Input

5 4
1
5
3
4
2
5
1
4
2

Sample Output

5
2
2
1

样例解释
(1,5,3,4,2)(1,3,4,2)(3,4,2)(3,2)(3)。

HINT

N<=100000 M<=50000



做法1：cdq分治

1、首先我们看到求逆序对，很容易想到用树状数组去求逆序对，这里在有修改的情况下，我们一样用树状数组来做，只是再加上cdq分治。


2、首先我们倒过来做，把删除看成添加操作。比如例题：它的添加顺序是(数值)：3(没有被删除的数先添加)、2、4、1、5。


3、然后我们来定义一个数组a,三个属性id(添加操作的顺序),val(数值的大小),pv(在序列里的位置)。


4、按照id来排序。 然后我们对val来分治，用pv来更新和求值。


5、注意要更新两次和求值两次，具体看代码，再叠加起来就可。


代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<vector>
#include<bitset>
#include<set>
#include<queue>
#include<stack>
#include<map>
#include<cstdlib>
#include<cmath>
#define PI 2*asin(1.0)
#define LL long long
#define pb push_back
#define pa pair<int,int>
#define clr(a,b) memset(a,b,sizeof(a))
#define lson lr<<1,l,mid
#define rson lr<<1|1,mid+1,r
#define bug(x) printf("%d++++++++++++++++++++%d\n",x,x)
#define key_value ch[ch[root][1]][0]C:\Program Files\Git\bin
const int  MOD = 1E9+7;
const LL N = 1E5+15;
const int maxn = 1e4+1000;
const int letter = 130;
const int INF = 1e17;
const double pi=acos(-1.0);
const double eps=1e-8;
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,k,val[N],c[N],vis[N],pp[N];
LL ans[N];
vector<int>ps;
struct node{
    int id,val,pv;
}a[N],b[N];
bool cmp(node a,node b){
    return a.id<b.id;
}
int lowbit(int x){return x&(-x);}
void update(int i,int v){
    for(int x=i;x<=n;x+=lowbit(x)) pp[x]+=v;
}
int getsum(int i){
    int ans=0;
    for(int x=i;x;x-=lowbit(x)) ans+=pp[x];
    return ans;
}
void solve(int l,int r){
    if(l==r) return;
    int mid=(l+r)>>1;/// val
    for(int i=l;i<=r;i++){
        if(a[i].val<=mid) update(a[i].pv,1);
        else ans[a[i].id]+=1ll*(getsum(n)-getsum(a[i].pv));
    }
    for(int i=l;i<=r;i++) if(a[i].val<=mid) update(a[i].pv,-1);
    for(int i=l;i<=r;i++){
        if(a[i].val>mid) update(a[i].pv,1);
        else ans[a[i].id]+=1ll*getsum(a[i].pv-1);
    }
    for(int i=l;i<=r;i++) if(a[i].val>mid) update(a[i].pv,-1);
    int ll=l;
    for(int i=l;i<=r;i++) if(a[i].val<=mid) b[ll++]=a[i];
    for(int i=l;i<=r;i++) if(a[i].val>mid) b[ll++]=a[i];
    for(int i=l;i<=r;i++) a[i]=b[i];
    solve(l,mid);
    solve(mid+1,r);
}
int main(){
    ps.clear();
    int x;
    n=read(),k=read();
    for(int i=1;i<=n;i++){
        a[i].val=read(),a[i].pv=i;
        c[a[i].val]=i;
    }
    for(int i=1;i<=k;i++){
        x=read();
        vis[c[x]]=1;
        ps.pb(c[x]);
    }
    int cnt=0;
    for(int i=1;i<=n;i++){
        if(!vis[i]) a[i].id=++cnt;
    }
    for(int i=ps.size()-1;i>=0;i--) a[ps[i]].id=++cnt;
    sort(a+1,a+cnt+1,cmp);
    solve(1,n);
    for(int i=1;i<=n;i++){
        ans[i]+=ans[i-1];
    }
    for(int i=k;i>=1;i--){
        printf("%lld\n",ans[n-k+i]);
    }
    return 0;
}
/*
5 4
1 5 3 4 2
5 1 4 2
5 5
5 4 3 2 1
5 4 3 2 1
*/

做法2： 可持久化线段树


这道题做了一天，超了一天的内存，傻逼了。= =，然后优化一下就过了，一脸蒙逼。


1、注意一下数据范围：n<=100000 m<=50000。一开始做的时候我用的是n个数去维护可持久化线段树，各种超内存。


2、仔细想了一下我们有n-m个数没有变过，所以我们离线处理。其他m个点，插入用可持久化线段树即可。


#include<cstdio>
#include<cstring>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<vector>
#include<bitset>
#include<set>
#include<queue>
#include<stack>
#include<map>
#include<cstdlib>
#include<cmath>
#define PI 2*asin(1.0)
#define LL long long
#define pb push_back
#define pa pair<int,int>
#define clr(a,b) memset(a,b,sizeof(a))
#define lson lr<<1,l,mid
#define rson lr<<1|1,mid+1,r
#define bug(x) printf("%d++++++++++++++++++++%d\n",x,x)
#define key_value ch[ch[root][1]][0]C:\Program Files\Git\bin
const int  MOD = 1E9+7;
const LL N = 1E5+15;
const int maxn = 1e4+1000;
const int letter = 130;
const int INF = 1e17;
const double pi=acos(-1.0);
const double eps=1e-8;
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,k,val[N],w[N],c[N],d[N];
int sum[N*100],ls[N*100],rs[N*100],root[N],siz,ps[N],vis[N];
int pl[50],pr[50],aa,bb;
int vl[N],vr[N];
vector<LL>pp;
int lowbit(int x){
    return x&(-x);
}
void update(int i,int val){
    for(int x=i;x<=n;x+=lowbit(x)) ps[x]+=val;
}
int getsum(int i){
    int ans=0;
    for(int x=i;x>0;x-=lowbit(x)) ans+=ps[x];
    return ans;
}
void insert(int ll,int rr,int x,int &y,int v,int add){
    y=++siz;
    sum[y]=sum[x]+add;
    ls[y]=ls[x],rs[y]=rs[x];
    if(ll==rr) return;
    int mid=(ll+rr)>>1;
    if(v<=mid) insert(ll,mid,ls[x],ls[y],v,add);
    else insert(mid+1,rr,rs[x],rs[y],v,add);
}
int query(int l,int r,int w){ ///1 n w
    int suml=0,sumr=0;
    if(l==r){
        for(int i=0;i<aa;i++) suml+=sum[pl[i]];
        for(int i=0;i<bb;i++) sumr+=sum[pr[i]];
        return sumr-suml;
    }
    int mid=(l+r)>>1;
    for(int i=0;i<aa;i++) suml+=sum[ls[pl[i]]];
    for(int i=0;i<bb;i++) sumr+=sum[ls[pr[i]]];
    if(w<=mid){
        for(int i=0;i<aa;i++) pl[i]=ls[pl[i]];
        for(int i=0;i<bb;i++) pr[i]=ls[pr[i]];
        return query(l,mid,w);
    }
    else {
        for(int i=0;i<aa;i++) pl[i]=rs[pl[i]];
        for(int i=0;i<bb;i++) pr[i]=rs[pr[i]];
        return sumr-suml+query(mid+1,r,w);
    }
}
void init(){
    pp.clear();
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        val[i]=read();
        w[val[i]]=i; ///at
    }
    for(int i=1;i<=k;i++){
        int x;
        x=read();
        d[i]=x;
        c[i]=w[x];
        vis[c[i]]=1;
    }
    LL ans=0;
    int cnt=0;
    for(int i=1;i<=n;i++){
        if(!vis[i]){ ///no
            update(val[i],1);
            ans+=1ll*(cnt-getsum(val[i]-1));
            cnt++;
        }
        else {  /// shanchu
            vl[i]=cnt-getsum(val[i]-1);
        }
    }
    cnt=0;
    clr(ps,0);
    for(int i=n;i>=1;i--){
        if(!vis[i]){
            update(val[i],1);
        }
        else {
            vr[i]=getsum(val[i]-1);
        }
    }
    clr(ps,0);
    for(int i=k;i>=1;i--){
        aa=bb=0;
        for(int j=c[i];j<=n;j+=lowbit(j)) insert(1,n,root[j],root[j],d[i],1);
        for(int j=c[i]-1;j;j-=lowbit(j)) pr[bb++]=root[j];
        update(c[i],1);
        ans+=1ll*((LL)getsum(c[i]-1)-(LL)query(1,n,d[i]-1)+vl[c[i]]);
        aa=bb=0;
        for(int j=c[i];j;j-=lowbit(j)) pl[aa++]=root[j];
        for(int j=n;j;j-=lowbit(j)) pr[bb++]=root[j];
        ans+=1ll*(vr[c[i]]+query(1,n,d[i]-1));
        pp.pb(ans);
    }
    for(int i=pp.size()-1;i>=0;i--) printf("%lld\n",pp[i]);
}
int main(){
   // freopen("input.txt","r",stdin);
   // freopen("out.txt","w",stdout);
    init();
    return 0;
}
/*
5 4
1 5 3 4 2
5 1 4 2
10 5
10 9 8 7 6 5 4 3 2 1
5 4 3 2 1
5 3
5 4 3 2 1
3 2 1
*/



捣乱天才
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CDQ分治（含例题：货币兑换、PARTIAL ORDER）
初学者
07-12 721
最近在整理原来的一些资料，偶然想起原来搞OI时讲过一次CDQ分治的内容，这里分享给大家 目录 预备知识 常见递归复杂度 分治思想 CDQ分治例题 货币兑换 PARTIAL ORDER 问题2D版本 问题3D版本 问题4D简化版本 问题4D版本 问题100D版本 总结 题目推荐 CDQ分治是一种特殊的分治方法，在OI界初见于陈丹琦2008年国家集训队作业中 预备知识 常见递归复杂度 先来分析下面这个递归方程： 其时间复杂度如何分析？ 将式子迭代两次得..
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样...
【可持久化线段树】【主席树】[BZOJ 3295]动态逆序对
weixin_30586257的博客
01-24 95
对于序列A，它的逆序对数定义为满足i<j，且Ai>Aj的数对(i,j)的个数。给1到n的一个排列，按照某种顺序依次删除m个元素，你的任务是在每次删除一个元素之前统计整个序列的逆序对数。 这里可以发现对于每一个数字可以有两种做法第一种就是先建好树然后每一次删除询问在他之前有多少个比他大的，询问有多少个比他小的在他之后，然后减去（不推荐该做法） 另一种做法就是首先预处理...
BZOJ 3932 [CQOI2015]任务查询系统 可持久化线段树
とある黄鱼のOIブログ
01-04 492
以时间戳划分，每个时间点维护一个线段树，任务开始时在对应权值处+1，结束后-1就好啦。上可持久化线段树。 感觉分配内存还是动态一大段一大段分比较好。。RE了才知道要调大数组。 #include #include using namespace std; const int M = 100001; typedef long long ll; struct Tree { Tree *l
bzoj3295: [Cqoi2011]动态逆序对
Fsss
04-24 617
链接：http://www.lydsy.com/JudgeOnline/problem.php?id=3295 题意：中午题。 分析：本来打算练习cdq分治的，明天补吧。不过看到这题一眼就想用可持久化线段树，不过带修改的可持久化线段树开销有点大，变了一种方法卡了点空间才过。详见代码。O(nlogn*logn)。 代码： #include #include #include #include
bzoj3295: [Cqoi2011]动态逆序对（树套树）
weixin_30814319的博客
05-26 74
1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cmath> 5 #include <algorithm> 6 #define maxn 100005 7 #define maxk 6000005 8...
Jzoj1020 逆序对统计 ≈ Bzoj3295 动态逆序对
扩展の灰(Extended Ash/Cooevjnz)
12-11 617
Jzoj1020: Dramatic是在太菜了。最近，他学习了有关逆序对的知识，并且掌握了计算一个序列逆序对个数的高效算法，因此，他兴冲冲的跑去向YY牛炫耀。YY牛对此不屑一顾，并打击Dramatic说：“这是在太小儿科了！”Dramatic很不甘心，于是在他的强烈要求下，YY牛给他出了一道跟逆序对有关的“难题”（显然，对于YY牛来说是简单题）。题目是这样的：YY牛首先给Dramatic一个长
整体二分&CDQ分治：[BZOJ2527][POI2011] meteors [BZOJ3295][CQOI2011] 动态逆序对
whzzt的博客
08-15 582
首先我们先说说3295题的树套树做法：显然只需要求出每次修改x左边比自身大的数的个数和右边比自身小的个数，就是x的贡献，每次减去贡献再删除x即可，这样就相当于带修改的可持久化线段树就能解决问题。显然，我们用树状数组套权值线段树来解决这个问题，每次修改就相当于修改棵可持久化线段树上的一个权值，所以在修改上总的时间复杂度是，下面来考虑查询。 我们每次查询显然可以分成段，这样我们显然可以来完成所有的查
bzoj 3295 动态逆序对 （三维偏序，CDQ+树状数组）
weixin_30892889的博客
08-23 71
链接：https://www.lydsy.com/JudgeOnline/problem.php?id=3295 思路： 可以将这道题看成倒着插入，这样就可以转化成求逆序对数，用CDQ分治降维，正反用树状数组求两遍逆序对就好了。 这道题还可以用在线的树套树或者可持久化线段树来写。。 实现代码： #include<bits/stdc++.h> using namespac...
bzoj3237 [Ahoi2013]连通图 线段树分治+并查集按秩合并
olahiuj的博客
12-27 228
Description 给定n个点m条边的无向图，k次询问，每次删除s条边并询问此时图的连通性，询问互相独立。 n&lt;=1e5,m&lt;=2e5,k&lt;=1e5,s&lt;=4 Solution 传说中的线段树分治 删除和插入同时存在的话非常麻烦，因此考虑一种处理询问的顺序使得只剩插入操作 我们把一条边存在的询问区间扔进线段树，然后遍历整棵线段树。遍历的时候就插入区间内的边，同时压进...
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
03-17
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
Link-Cut-Tree 动态树经典讲稿附例题
10-11
适用ACM和OI等算法选手，Link-Cut-Tree 动态树经典讲稿，附BZOJ多道优秀练习题，原作者吉大附中实验学校 PoPoQQQ
wangjunrui666#bzoj-problem##3106. [cqoi2013]棋盘游戏1
07-25
比如n=2，白棋子在(1,1)，黑棋子在(2,2)，那么虽然A有两种走法，第二个回合B总能取胜。白色棋子在(r1,c1)，黑色棋子在(r2,c2)（1,
wangjunrui666#bzoj-problem##3507. [Cqoi2014]通配符匹配1
07-25
最常见的通配符有两个，一个是星号(“”’)，可以匹配0个及以上的任意字符：另一个是问号(“？现在需要你编写一个程序，对于给定的文件名列表和一个包含通配符的字符串
大学生挑战杯-喜树根器官培养和抗癌物质喜树碱生成的研究.rar
07-26
大学生挑战杯-喜树根器官培养和抗癌物质喜树碱生成的研究.rar
b278视频及游戏管理平台-springboot+vue.zip（可运行源码+sql文件+）
07-26
视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。 视频及游戏管理平台是一个很好的项目，结合了后端（Spring Boot）和前端（Vue.js）技术，实现了前后端分离。
大模型应用-为Ollma开发的简单的HTML网页UI应用-附项目源码-优质项目实战.zip
最新发布
07-26
大模型应用_为Ollma开发的简单的HTML网页UI应用_附项目源码_优质项目实战
基于JAVA局域网监听软件的设计与开发(源代码+论文).rar
07-26
基于JAVA局域网监听软件的设计与开发(源代码+论文).rar
【学习笔记】可持久化并查集（BZOJ3673）
05-22
可持久化并查集是指在并查集基础上，新增了时间维度，即支持查询历史版本的并查集信息。 主要应用场景是需要记录数据变化历史的问题，比如线段树合并、动态图连通性等。 以下是实现可持久化并查集的基本思路： 1. 每个节点维护一个 father 数组，表示该节点的祖先节点 2. 对于每个版本，使用一个 map（键值对）来记录每个节点的祖先节点 3. 合并操作时，将两个节点的祖先节点找出来，若不同就将其中一个节点的祖先节点指向另一个节点的祖先节点 4. 查询操作时，查询对应版本的 map，返回节点的祖先节点 具体实现时，可以使用并查集路径压缩和按秩合并优化，以提高效率。 以下是代码实现（C++）：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值