BZOJ 3295 CQOI 2011 动态逆序对 线段树套Treap

题目大意:给出一个数列,每次从这个序列中删掉一个数字,问每次删之前逆序对的数量是多少。

思路:这个题用CDQ分治是飞快的,然而我不知道怎么写。。于是就朴素的写了树套树。然后就朴素的被卡常了

内层用一个线段树。这个线段树不修改,一开始就要建好,然后线段树的每一个节点维护一个平衡树,存的是线段树存的区间中所有的值。

一开始先算一下逆序对数,然后每次删点的时候,先查询在这个点之前有多少大于他的,后面有多少小于他的,总的逆序对中将这些减掉。这个过程通过树套树不难实现。

CODE(交了这个代码T掉的,请选择在人多的时候先交一发糖果公园再交一次本题即可。。。因为多人测的时候会放宽一点时限。。。

你们感受一下

):

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAX 100010
using namespace std;
#define LEFT (pos << 1)
#define RIGHT (pos << 1|1)
#define SIZE(a) ((a) == NULL ? 0:a->size)

namespace IStream{
    const int L=1<<15;
    char buffer[L],*S,*T;
    inline char Get_Char()
    {
        if(S==T)
        {
            T=(S=buffer)+fread(buffer,1,L,stdin);
            if(S==T) return EOF;
        }
        return *S++;
    }
    inline int GetInt()
    {
        char c;
        int re=0;
        for(c=Get_Char();c<'0'||c>'9';c=Get_Char());
        while(c>='0'&&c<='9')
            re=(re<<1)+(re<<3)+(c-'0'),c=Get_Char();
        return re;
    }
}  

/*class OStream{
    private:
        static const int L=1<<15;
        char stack[20];int top;
        char buffer[L],*S;
    public:
        OStream()
        {
            S=buffer;
        }
        void PutLongLong(long long x)
        {
            stack[++top]='\n';
            if(!x) stack[++top]='0';
            else while(x)
                stack[++top]=x%10+'0',x/=10;
            while(top)
            {
                if(S==buffer+L-1)
                {
                    printf("%s",buffer);
                    S=buffer;
                }
                *S++=stack[top--];
            }
        }
        ~OStream()
        {
            *S=0;
            puts(buffer);
        }
}os;*/

int cnt,asks;
int src[MAX],pos[MAX];
int fenwick[MAX];
long long inv;

struct Treap{
	int random,val,size;
	Treap *son[2];

	Treap(int _) {
		val = _;
		random = rand();
		size = 1;
		son[0] = son[1] = NULL;
	}
	int Compare(int x) {
		if(x == val)	return -1;
		return x > val;
	}
	void Maintain() {
		size = 1;
		if(son[0] != NULL)	size += son[0]->size;
		if(son[1] != NULL)	size += son[1]->size;
	}
}*tree[MAX << 2];

inline int GetSum(int x)
{
	int re = 0;
	for(; x < MAX; x += x&-x)
		re += fenwick[x];
	return re;
}

inline void Fix(int x,int c)
{
	for(; x; x -= x&-x)
		fenwick[x] += c;
}

inline void Rotate(Treap *&a,bool dir)
{
	Treap *k = a->son[!dir];
	a->son[!dir] = k->son[dir];
	k->son[dir] = a;
	a->Maintain(),k->Maintain();
	a = k;
}

void Insert(Treap *&a,int x)
{
	if(a == NULL) {
		a = new Treap(x);
		return ;
	}
	int dir = a->Compare(x);
	Insert(a->son[dir],x);
	if(a->son[dir]->random > a->random)
		Rotate(a,!dir);
	a->Maintain();
}

void Delete(Treap *&a,int x)
{
	int dir = a->Compare(x);
	if(dir != -1)
		Delete(a->son[dir],x);
	else {
		if(a->son[0] == NULL)	a = a->son[1];
		else if(a->son[1] == NULL)	a = a->son[0];
		else {
			int _ = (a->son[0]->random > a->son[1]->random);
			Rotate(a,_);
			Delete(a->son[_],x);
		}
	}
	if(a != NULL)	a->Maintain();
}

int Ask(Treap *a,int x)
{
	if(a == NULL)	return 0;
	if(a->val > x)	return Ask(a->son[0],x);
	if(a->val == x)	return SIZE(a->son[0]);
	return SIZE(a->son[0]) + 1 + Ask(a->son[1],x);
}

void BuildTree(int l,int r,int pos)
{
	for(int i = l; i <= r; ++i)
		Insert(tree[pos],src[i]);
	if(l == r)	return ;
	int mid = (l + r) >> 1;
	BuildTree(l,mid,LEFT);
	BuildTree(mid + 1,r,RIGHT);
}

void Delete(int l,int r,int x,int pos,int c)
{
	Delete(tree[pos],c);
	if(l == r)	return ;
	int mid = (l + r) >> 1;
	if(x <= mid)	Delete(l,mid,x,LEFT,c);
	else	Delete(mid + 1,r,x,RIGHT,c);
}

int Ask(int l,int r,int x,int y,int pos,int c)
{
	if(l == x && y == r)
		return Ask(tree[pos],c);
	int mid = (l + r) >> 1;
	if(y <= mid)	return Ask(l,mid,x,y,LEFT,c);
	if(x > mid)	return Ask(mid + 1,r,x,y,RIGHT,c);
	int left = Ask(l,mid,x,mid,LEFT,c);
	int right = Ask(mid + 1,r,mid + 1,y,RIGHT,c);
	return left + right;
}

int main()
{
	srand(19970815);
	cin >> cnt >> asks;
	for(int i = 1; i <= cnt; ++i) {
		src[i] = IStream::GetInt();
		//scanf("%d",&src[i]);
		pos[src[i]] = i;
		inv += GetSum(src[i]);
		Fix(src[i],1);
	}
	BuildTree(1,cnt,1);

	memset(fenwick,0,sizeof(fenwick));
	for(int i = 1; i <= cnt; ++i)
		Fix(i,1);
	for(int x,i = 1; i <= asks; ++i) {
		printf("%lld\n",inv);
		//os.PutLongLong(inv);
		x = IStream::GetInt();
		//scanf("%d",&x);
		Delete(1,cnt,pos[x],1,x);
		Fix(pos[x],-1);
		if(pos[x] != 1)
			inv -= (GetSum(1) - GetSum(pos[x]) - Ask(1,cnt,1,pos[x] - 1,1,x));
		if(pos[x] != cnt)
			inv -= Ask(1,cnt,pos[x] + 1,cnt,1,x);
	}
	return 0;
}
时间: 2024-11-05 18:46:45

BZOJ 3295 CQOI 2011 动态逆序对 线段树套Treap的相关文章

【BZOJ 3295】 [Cqoi2011]动态逆序对

3295: [Cqoi2011]动态逆序对 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 1373  Solved: 465 [Submit][Status][Discuss] Description 对于序列A,它的逆序对数定义为满足i<j,且Ai>Aj的数对(i,j)的个数.给1到n的一个排列,按照某种顺序依次删除m个元素,你的任务是在每次删除一个元素之前统计整个序列的逆序对数. Input 输入第一行包含两个整数n和m,即初始元素的个数

BZOJ 3295:[Cqoi2011]动态逆序对(三维偏序 CDQ分治+树状数组)

http://www.lydsy.com/JudgeOnline/problem.php?id=3295 题意:简单明了. 思路:终于好像有点明白CDQ分治处理三维偏序了.把删除操作看作是插入操作,那么可以按照插入的时间顺序看作是一维x,插入的数在原本序列的下标是一维y,插入的数本身是一维z.那么问题可以转化成每插入一个数(xx,yy,zz),求有多少个数(x,y,z)使得 x < xx,y < yy,z > zz .一开始先对 x 进行排序,然后进行CDQ分治.这样可以干掉一维,保证随

[CQOI 2011]动态逆序对

Description 题库链接 对于序列 \(A\) ,它的逆序对数定义为满足 \(i<j\) ,且 \(A_i>A_j\) 的数对 \((i,j)\) 的个数.给 \(1\) 到 \(n\) 的一个排列,按照某种顺序依次删除 \(m\) 个元素,你的任务是在每次删除一个元素之前统计整个序列的逆序对数. Solution 好久以前的坑了... 解法一 考虑树套树. 删去一个数,减少的逆序对个数是当前位置之前比当前数大的个数以及在这个数的位置之后比当前数小的个数. 如果不支持修改显然是可以用主

bzoj 3295: [Cqoi2011]动态逆序对(树套树 or CDQ分治)

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

BZOJ 3196 二逼平衡树 树套树(线段树套Treap)

题目大意: 写一种数据结构,他可以: 1.查询k在区间内的排名. 2.查询区间内排名为k的值 3.修改某一个值. 4.求k在区间内的前驱. 5.求k在区间内的后继. 思路:本来以为有什么只有神犇才知道的神一般的数据结构来维护它,问了别人之后,发现只是树套树.据说怎么套都行.我见识鄙陋,就只能线段树套Treap了. 这也是第一次写树套树,还1A了,有点开心. 写树套树,一定要确定自己对这两个树及其熟练,加上少量精细的思考,就可以完成树套树.(我只是弱渣,求神犇别D) 具体实现:第一层是线段树,第二

bzoj 3196 &amp;&amp; luogu 3380 JoyOI 1730 二逼平衡树 (线段树套Treap)

链接:https://www.lydsy.com/JudgeOnline/problem.php?id=3196 题面; 3196: Tyvj 1730 二逼平衡树 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 6372  Solved: 2406[Submit][Status][Discuss] Description 您需要写一种数据结构(可参考题目标题),来维护一个有序数列,其中需要提供以下操作:1.查询k在区间内的排名2.查询区间内排名为

【bzoj3196】 Tyvj 1730 二逼平衡树 线段树套Treap

题目描述 您需要写一种数据结构(可参考题目标题),来维护一个有序数列,其中需要提供以下操作:1.查询k在区间内的排名2.查询区间内排名为k的值3.修改某一位值上的数值4.查询k在区间内的前驱(前驱定义为小于x,且最大的数)5.查询k在区间内的后继(后继定义为大于x,且最小的数) 输入 第一行两个数 n,m 表示长度为n的有序序列和m个操作第二行有n个数,表示有序序列下面有m行,opt表示操作标号若opt=1 则为操作1,之后有三个数l,r,k 表示查询k在区间[l,r]的排名若opt=2 则为操

逆序对 线段树&amp;树状数组

17年的时候在HDU新生赛的时候遇到这样一道题目, 当时对于这种题目, 只会n^2去数左边比他大的个数 再相加一下 就是答案了. 无奈n是1e5 毫无疑问的T了. 后来学长说这个不就是归并排序吗, 你去学一下归并就可以做了, 然后我去学了归并, 又交了一发, 结果竟然还是T(这Y的不是耍我玩吗). 然后从另一位学长哪里听说了用线段树去求逆序对, 把n^2变成nlogn就不会T了,最后, 我又学了线段树,终于这回AC了.写这个帖子的时候,我顺便去HDU找了找这道题目,结果找不到这道题目,竟然没挂出

【bzoj3295】动态逆序对 分块+树状数组

题目描述 给定一个1~n的序列,然后m次删除元素,每次删除之前询问逆序对的个数. 代码 #include <cstdio> #include <cctype> #include <cmath> #include <algorithm> using namespace std; typedef long long lint; const int N=100010; const int BLOCK_SIZE=1000; const int BLOCK_NUM=1