P1908 逆序对 ( 离散化 / 动态开点 )

最新推荐文章于 2023-10-29 16:03:17 发布
原创 最新推荐文章于 2023-10-29 16:03:17 发布
· 199 阅读 · 1 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了三种解决大范围逆序对问题的方法：树状数组结合离散化，线段树离散化，以及线段树动态开点。通过离散化策略，将数值范围缩小便于高效操作，展示了如何在1e9范围内求解并优化代码实现。

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

题目链接：点击进入
题目

在这里插入图片描述
在这里插入图片描述

思路1（树状数组+离散化）

求逆序对，这个题给的范围为 1e9 ，正常的话是将数作为下标并修改对应值，但是这里要是将数当作下标肯定不行，因为开不了 1e9 那么大的数组，因此我们对其离散化一下 ( 也就是排序，按照大小赋予编号 )，这样我们用编号进行树状数组的修改，数组最大只需要开1e6 即可。( 仔细想一下，离散化其实就是将原来中间没有赋值的那些位置除去了，留下只会被用到的位置，虽然给这些位置重新编号了，但是实际上相对位置是没变的 )
离散结束就是正常的操作了，例如此题。

代码1
//#pragma GCC optimize(3)//O3
//#pragma GCC optimize(2)//O2
#include<iostream>
#include<string>
#include<map>
#include<set>
//#include<unordered_map>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<fstream>
#define X first
#define Y second
#define best 131 
#define INF 0x3f3f3f3f3f3f3f3f
#define pii pair<int,int>
#define lowbit(x) x & -x
#define inf 0x3f3f3f3f
#define int long long
//#define double long double
//#define rep(i,x,y) for(register int i = x; i <= y;++i)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const int maxn=1e6+10;
const int mod=1e9+7;
const double eps=1e-9;
const int N=5e3+10;
/*--------------------------------------------*/
inline int read()
{
    int k = 0, f = 1 ;
    char c = getchar() ;
    while(!isdigit(c)){if(c == '-') f = -1 ;c = getchar() ;}
    while(isdigit(c)) k = (k << 1) + (k << 3) + c - 48 ,c = getchar() ;
    return k * f ;
}
/*--------------------------------------------*/

int n,c[maxn],mp[maxn],ans;
struct node
{
	int pos;
	int num;
	bool operator < (const node&t)const
	{
		return num<t.num;
	}
}p[maxn];

void add(int x,int d)
{
	for(int i=x;i<=n;i+=lowbit(i)) c[i]+=d;
}
int getsum(int x)
{
	int sum=0;
	for(int i=x;i>=1;i-=lowbit(i)) sum+=c[i];
	return sum;
}

signed main() 
{
//	ios::sync_with_stdio(false);
//	cin.tie(0);cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>p[i].num;
		p[i].pos=i;
	}
	sort(p+1,p+n+1);
	int cnt=1;
	mp[p[1].pos]=cnt;
	for(int i=2;i<=n;i++) 
	{
		if(p[i].num==p[i-1].num)
			mp[p[i].pos]=cnt;
		else
			mp[p[i].pos]=++cnt;
	}
	for(int i=1;i<=n;i++)
	{
		ans=ans+(getsum(n)-getsum(mp[i]));
		add(mp[i],1);
	}
	cout<<ans<<endl;
    return 0;
}
思路2（线段树+离散化）

一个意思，线段树开不了 4e9 的空间，因此离散化一下 ( 也就是排序，按照大小赋予编号 )，这样我们只需要对离散后的编号操作即可，因为相对大小关系没变化，因此求得的数量是一样的。

代码2
//#pragma GCC optimize(3)//O3
//#pragma GCC optimize(2)//O2
#include<iostream>
#include<string>
#include<map>
#include<set>
//#include<unordered_map>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<fstream>
#define X first
#define Y second
#define best 131 
#define INF 0x3f3f3f3f3f3f3f3f
#define pii pair<int,int>
#define lowbit(x) x & -x
#define inf 0x3f3f3f3f
#define int long long
//#define double long double
//#define rep(i,x,y) for(register int i = x; i <= y;++i)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const int maxn=1e6+10;
const int mod=1e9+7;
const double eps=1e-9;
const int N=5e3+10;
/*--------------------------------------------*/
inline int read()
{
    int k = 0, f = 1 ;
    char c = getchar() ;
    while(!isdigit(c)){if(c == '-') f = -1 ;c = getchar() ;}
    while(isdigit(c)) k = (k << 1) + (k << 3) + c - 48 ,c = getchar() ;
    return k * f ;
}
/*--------------------------------------------*/

int n,mp[maxn],ans;
struct node
{
	int pos;
	int num;
	bool operator < (const node&t)const
	{
		return num<t.num;
	}
}p[maxn];
struct Node
{
	int l;
	int r;
	int sum;
}t[maxn<<2];

void pushup(int p)
{
	t[p].sum=t[p<<1].sum+t[p<<1|1].sum;
}
void build(int p,int l,int r)
{
	t[p].l=l,t[p].r=r,t[p].sum=0;
	if(l==r) return ;
	int mid=l+r>>1;
	build(p<<1,l,mid);
	build(p<<1|1,mid+1,r);
	pushup(p);
}
void change(int p,int x,int d)
{
	if(t[p].l==t[p].r)
	{
		t[p].sum+=d;
		return ;
	}
	int mid=t[p].l+t[p].r>>1;
	if(x<=mid) change(p<<1,x,d);
	else change(p<<1|1,x,d);
	pushup(p);
}
int ask(int p,int l,int r)
{
	if(l<=t[p].l&&t[p].r<=r)
		return t[p].sum;
	int mid=t[p].l+t[p].r>>1,ans=0;
	if(l<=mid) ans+=ask(p<<1,l,r);
	if(r>mid) ans+=ask(p<<1|1,l,r);
	return ans;
}

signed main() 
{
//	ios::sync_with_stdio(false);
//	cin.tie(0);cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>p[i].num;
		p[i].pos=i;
	}
	
	sort(p+1,p+n+1);
	int cnt=1;
	mp[p[1].pos]=cnt;
	for(int i=2;i<=n;i++) 
	{
		if(p[i].num==p[i-1].num)
			mp[p[i].pos]=cnt;
		else
			mp[p[i].pos]=++cnt;
	}
	
	build(1,1,cnt);
	for(int i=1;i<=n;i++)
	{
		change(1,mp[i],1);
		ans=ans+(i-ask(1,1,mp[i]));
	}
	cout<<ans<<endl;
    return 0;
}
思路3（线段树+动态开点）

线段树开不了 4e9 的空间，那我们可以考虑动态开点，也就是说我们没有用到的那些节点，我们不去赋予它空间，只给那些有用的点空间即可。而对于这种用到才开点的方式也就意味着不能通过 p<<1 , p<<1|1 的方式，访问子节点了，编号变成乱序的了。也就是t [ p ] . l 、 t [ p ]. r 存的是左右孩子的下标，但是编号是乱序的，是我们需要使用时现加上去的。
( 注：更新函数里下标 p 前面的 & 不可省略 )
这里用了动态开点，就可以不用离散化，直接1~1e9操作即可。

代码3
//#pragma GCC optimize(3)//O3
//#pragma GCC optimize(2)//O2
#include<iostream>
#include<string>
#include<map>
#include<set>
//#include<unordered_map>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#include<algorithm>
#include<iomanip>
#include<cmath>
#include<fstream>
#define X first
#define Y second
#define best 131 
#define INF 0x3f3f3f3f3f3f3f3f
#define pii pair<int,int>
#define lowbit(x) x & -x
#define inf 0x3f3f3f3f
//#define int long long
//#define double long double
//#define rep(i,x,y) for(register int i = x; i <= y;++i)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const int maxn=1e7+10;
const int mod=1e9+7;
const double eps=1e-9;
const int N=5e3+10;
/*--------------------------------------------*/
inline int read()
{
    int k = 0, f = 1 ;
    char c = getchar() ;
    while(!isdigit(c)){if(c == '-') f = -1 ;c = getchar() ;}
    while(isdigit(c)) k = (k << 1) + (k << 3) + c - 48 ,c = getchar() ;
    return k * f ;
}
/*--------------------------------------------*/

int n,a[maxn],root,cnt,limit;
ll ans;
struct node
{
	int l;
	int r;
	int sum;
}t[maxn];

void pushup(int p)
{
	t[p].sum=t[t[p].l].sum+t[t[p].r].sum;
}
void change(int &p,int l,int r,int x,int d)
{
	if(!p) p=++cnt;
	if(l==r)
	{
		t[p].sum+=d;
		return ;
	}
	int mid=l+r>>1;
	if(x<=mid) change(t[p].l,l,mid,x,d);
	else change(t[p].r,mid+1,r,x,d);
	pushup(p);
}
int ask(int p,int l,int r,int x,int y)
{
	if(!p) return 0;
	if(x<=l&&r<=y)
		return t[p].sum;
	int mid=l+r>>1,ans=0;
	if(x<=mid) ans+=ask(t[p].l,l,mid,x,y);
	if(y>mid) ans+=ask(t[p].r,mid+1,r,x,y);
	return ans;
}

int main() 
{
//	ios::sync_with_stdio(false);
//	cin.tie(0);cout.tie(0);
	limit=1e9;
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=n;i++)
	{
		change(root,1,limit,a[i],1);
		ans=ans+(i-ask(root,1,limit,1,a[i]));
	}
	cout<<ans<<endl;
    return 0;
}
P1908 逆序对
xywy的博客
06-27 381
树状数组+离散化 离散化的技巧就是给输入的顺序按权值（输入的值）排序 如 [5,4,2,6,3,1] 排完序后得到的顺序序列就是 [6,3,5,2,1,4] 两者的逆序对数量相等。 我们可以这么理解：在这个有序序列中任意选一个数，对于这个数来说，它前面的所有数都小于它，如果前面数在原数组中的下标大于它，则构成一个逆序对。...
【题解】poj2299 树状数组求逆序对+离散化
翻过这座山，他们就会听到你的故事
08-26 395
题目链接 //采用树状数组求逆序对 离散化 #include&amp;lt;cstdio&amp;gt; #include&amp;lt;algorithm&amp;gt; #include&amp;lt;cstring&amp;gt; using namespace std; typedef long long ll; const int N=5e5+10; struct node { int p,v; }q[N]; int ...
luoguP1908 逆序对（CDQ分治）
。
09-01 346
题目描述 猫猫 TOM 和小老鼠 JERRY 最近又较量上了，但是毕竟都是成年人，他们已经不喜欢再玩那种你追我赶的游戏，现在他们喜欢玩统计。 最近，TOM 老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中a_i>a_jai​>aj​且i<ji<j的有序对。知道这概念后，他们就比赛谁先算出给定的一段正整数序列中逆序对的数目。注意序列中可能有重复数字。 Update:数据已加强。 输入格式 第一行，一个数nn，表...
求逆序对（归并排序）
wjc1761659069的博客
12-13 698
题目描述 猫猫TOM和小老鼠JERRY最近又较量上了，但是毕竟都是成年人，他们已经不喜欢再玩那种你追我赶的游戏，现在他们喜欢玩统计。最近，TOM老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中ai&gt;aj且i&lt;j的有序对。知道这概念后，他们就比赛谁先算出给定的一段正整数序列中逆序对的数目。Update:数据已加强。 输入输出格式...
逆序对
wzw-yali的博客
07-13 524
题目描述 猫猫TOM和小老鼠JERRY最近又较量上了，但是毕竟都是成年人，他们已经不喜欢再玩那种你追我赶的游戏，现在他们喜欢玩统计。最近，TOM老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中ai>aj且i 输入输出格式 输入格式： 第一行，一个数n，表示序列中有n个数。 第二行n个数，表示给定的序列。 输出格式： 给定序列中逆
【树状数组】【离散化】逆序对
blog
07-04 250
给定一个序列a1,a2,a3...an ，如果存在i<j 并且ai>aj ，那么我们称之为逆序对。 求序列中逆序对的数目。
p1908逆序对
最新发布
djsjsyajsg的博客
10-29 99
对于给定的一段正整数序列，逆序对就是序列中 �<�i<j 且��>��a​i​​>a​j​​ 的有序对 ，求一序列中有多少个逆序对。第一行：输入一个数 n ，表示序列有多少个数字。第二行：输入 n 个数字��a​i​​。数据保证序列中的数字互不相同。输出序列中逆序对的数目。
P1908-逆序对
weixin_30802273的博客
07-28 161
1 #include <bits/stdc++.h> 2 using namespace std; 3 #define _for(i,a,b) for(int i = (a);i < b;i ++) 4 const int maxn = 500009; 5 typedef long long ll; 6 int n; 7 ll a[maxn],c[m...
洛谷 P1908 逆序对(树状数组解法)
anshuo0835的博客
05-10 308
归并排序解法:https://www.cnblogs.com/lipeiyi520/p/10356882.html 题目描述 猫猫TOM和小老鼠JERRY最近又较量上了，但是毕竟都是成年人，他们已经不喜欢再玩那种你追我赶的游戏，现在他们喜欢玩统计。最近，TOM老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中ai>aj且i&...
【洛谷 P2513】 [HAOI2009]逆序对数列（DP）
06-07
- 在对原数列进行离散化时，需要记录每个元素在原数列中的位置，便于后面计算逆序对数； - 设树状数组的大小为 $n$，则树状数组中的下标从 $1$ 到 $n$，而不是从 $0$ 到 $n-1$； - 在计算逆序对数时，需要查询离散化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值