【二维偏序】【树状数组】【权值分块】【分块】poj2352 Stars

本文讨论了二维偏序问题的解决方法,通过树状数组和分块技术实现高效查询,适用于需要计算点集内左侧下方点数量的场景。

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

经典问题:二维偏序。给定平面中的n个点,求每个点左下方的点的个数。

因为 所有点已经以y为第一关键字,x为第二关键字排好序,所以我们按读入顺序处理,仅仅需要计算x坐标小于<=某个点的点有多少个就行。

这就是所说的:n维偏序,一维排序,二维树状数组,三维 分治 Or 树状数组套平衡树……

 

<法一>树状数组。

 1 #include<cstdio>
 2 #include<algorithm>
 3 #include<iostream>
 4 using namespace std;
 5 struct POINT
 6 {
 7     int x,y;
 8 };
 9 int n,d[3200001],ji[1500001],m;
10 POINT star[1500001];
11 bool cmp(const POINT &a,const POINT &b)
12 {
13     if(a.x<b.x)
14       return true;
15     else if(a.x>b.x)
16       return false;
17     else if(a.y<b.y)
18       return true;
19     return false;
20 }
21 int lowbit(int x)
22 {
23     return x&(-x);
24 }
25 void update(int x,int delta)
26 {
27     for(;x<=m;x+=lowbit(x))
28       d[x]+=delta;
29 }
30 int getsum(int x)
31 {
32     int res=0;
33     for(;x>0;x-=lowbit(x))
34       res+=d[x];
35     return res;
36 }
37 int main()
38 {
39     scanf("%d",&n);
40     for(int i=1;i<=n;i++)
41       {
42           scanf("%d%d",&star[i].x,&star[i].y);
43           star[i].y++;
44           m=max(m,star[i].y);
45       }
46     for(int i=1;i<=n;i++)
47       {
48           update(star[i].y,1);
49           ji[getsum(star[i].y)-1]++;
50       }
51     for(int i=0;i<n;i++)
52       printf("%d\n",ji[i]);
53     return 0;
54 }

<法二>权值分块。我会说比树状数组还快将近一倍?

 1 #include<cstdio>
 2 #include<cmath>
 3 #include<algorithm>
 4 using namespace std;
 5 int n,x[15001],y[15001],LIMIT,r[200],l[200],num[33000],sumv[200],sz,sum,rank[33000],b[33000];
 6 void makeblock()
 7 {
 8     sz=(int)sqrt((double)LIMIT); if(!sz) sz=1; r[0]=-1;
 9     for(sum=1;sum*sz<LIMIT;sum++)
10       {
11           l[sum]=r[sum-1]+1;
12           r[sum]=sum*sz;
13           for(int i=l[sum];i<=r[sum];i++) num[i]=sum;
14       }
15     l[sum]=r[sum-1]+1;
16     r[sum]=LIMIT;
17     for(int i=l[sum];i<=r[sum];i++) num[i]=sum;
18 }
19 int query(const int &V)
20 {
21     int cnt=0;
22     for(int i=1;i<num[V];i++) cnt+=sumv[i];
23     for(int i=l[num[V]];i<=V;i++) cnt+=b[i];
24     ++b[V]; ++sumv[num[V]];
25     return cnt;
26 }
27 int main()
28 {
29     scanf("%d",&n);
30     for(int i=1;i<=n;i++)
31       {
32           scanf("%d%d",&x[i],&y[i]);
33           LIMIT=max(LIMIT,x[i]);
34       } makeblock();
35     for(int i=1;i<=n;i++) ++rank[query(x[i])];
36     for(int i=0;i<n;i++) printf("%d\n",rank[i]);
37     return 0;
38 }

<法三>再介绍一种方便扩展到三维的方法。我们不用按x或者y单调插入。

我们发现,二维偏序实际上是二维树状数组的经典操作。

但是二维BIT的空间复杂度无法接受。

但是我们发现,将一维离散化之后,使其按权值单调,树状数组套平衡树 可以轻松查询 x、y同时小于等于一个点的点的个数。 空间复杂度O(n*log(n)) 时间复杂度O(n*log^2(n))。

然后我们又发现,这同样也是分块的经典操作。 空间复杂度O(n) 时间复杂度O(n*sqrt(n*log(n)))。 注意分块的时候,我们为了保证块的形态,要先按一维sort,然后每sqrt(n*log(n))个点分成一块,不能按权值分块。

 

分块姿势①

 1 #include<cstdio>
 2 #include<algorithm>
 3 #include<vector>
 4 #include<cmath>
 5 using namespace std;
 6 vector<int>b[200];
 7 struct Point{int x,y,num;}p[33000];
 8 vector<Point>a[200];
 9 int n,R,L,sum,l[200],r[200],sz,rank[33000];
10 void makeblock()
11 {
12     sz=(int)sqrt((double)n*(log((double)n)/log(2.0))); if(!sz) sz=1;
13     for(sum=1;sum*sz<n;sum++)
14       {
15           int R=sum*sz;
16           for(int i=(sum-1)*sz+1;i<=R;i++) p[i].num=sum;
17       }
18     for(int i=(sum-1)*sz+1;i<=n;i++) p[i].num=sum;
19 }
20 void update(const Point &U)
21 {
22     b[U.num].insert(upper_bound(b[U.num].begin(),b[U.num].end(),U.x),U.x);
23     a[U.num].push_back(U);
24 }
25 int query(const Point &U)
26 {
27     int cnt=0;
28     for(int i=1;i<U.num;++i) cnt+=upper_bound(b[i].begin(),b[i].end(),U.x)-b[i].begin();
29     for(vector<Point>::iterator it=a[U.num].begin();it!=a[U.num].end();++it)
30       if((*it).x<=U.x&&(*it).y<=U.y) ++cnt;
31     return cnt;
32 }
33 int main()
34 {
35     scanf("%d",&n);
36     for(int i=1;i<=n;i++) scanf("%d%d",&p[i].x,&p[i].y);
37     makeblock();
38     for(int i=1;i<=n;i++) update(p[i]);
39     for(int i=1;i<=n;i++) ++rank[query(p[i])-1];
40     for(int i=0;i<n;i++) printf("%d\n",rank[i]);
41     return 0;
42 }

分块姿势②

 1 #include<cstdio>
 2 #include<algorithm>
 3 #include<vector>
 4 #include<cmath>
 5 using namespace std;
 6 vector<int>b[200];
 7 struct Point{int x,y,num;}p[33000];
 8 vector<Point>a[200];
 9 int n,R,L,l[200],r[200],rank[33000];
10 void makeblock()
11 {
12     int sum,sz=(int)sqrt((double)n*(log((double)n)/log(2.0))); if(!sz) sz=1;
13     for(sum=1;sum*sz<n;sum++)
14       {
15           int R=sum*sz;
16           for(int i=(sum-1)*sz+1;i<=R;i++)
17           {
18               p[i].num=sum;
19               b[sum].push_back(p[i].x);
20               a[sum].push_back(p[i]);
21           }
22         sort(b[sum].begin(),b[sum].end());
23       }
24     for(int i=(sum-1)*sz+1;i<=n;i++)
25       {
26           p[i].num=sum;
27         b[sum].push_back(p[i].x);
28         a[sum].push_back(p[i]);
29       }
30     sort(b[sum].begin(),b[sum].end());
31 }
32 int query(const Point &U)
33 {
34     int cnt=0;
35     for(int i=1;i<U.num;++i) cnt+=upper_bound(b[i].begin(),b[i].end(),U.x)-b[i].begin();
36     for(vector<Point>::iterator it=a[U.num].begin();it!=a[U.num].end();++it)
37       if((*it).x<=U.x&&(*it).y<=U.y) ++cnt;
38     return cnt;
39 }
40 int main()
41 {
42     scanf("%d",&n);
43     for(int i=1;i<=n;i++) scanf("%d%d",&p[i].x,&p[i].y);
44     makeblock();
45     for(int i=1;i<=n;i++) ++rank[query(p[i])-1];
46     for(int i=0;i<n;i++) printf("%d\n",rank[i]);
47     return 0;
48 }

转载于:https://www.cnblogs.com/autsky-jadek/p/4116613.html

<think>好的,我现在需要帮助用户了解二维树状数组的实现和应用。首先,我得回顾一下用户之前的提问和引用内容,确保回答符合他们的需求。用户提到了二维树状数组,引用中也有关于二维前缀和、单点修改以及例题的信息,比如poj2352和Codeforces的题目。 首先,我需要解释二维树状数组的基本概念。二维树状数组树状数组二维空间的扩展,主要用于处理二维数组的前缀和查询和单点更新。用户可能已经了解一维树状数组,所以可以在此基础上进行扩展。 接下来是实现部分。用户需要具体的代码示例,尤其是Python的实现。根据引用3,一维树状数组的Python实现,我需要将其扩展到二维二维树状数组的操作包括初始化、单点更新和前缀和查询。需要注意的是,二维情况下,每个更新和查询操作都需要双重循环,遍历每个维度上的索引。 然后是应用场景。用户可能想知道在什么情况下使用二维树状数组。根据引用2和4,二维树状数组适用于子矩阵求和、动态二维网格数据更新等场景,比如处理二维偏序问题或实时更新矩阵中的元素值。例如,在POJ 1195这道题中,需要处理手机的更新和区域查询,这正是二维树状数组的典型应用。 另外,用户可能关心时间复杂度。每个操作的时间复杂度是O((log n)^2),因为每个维度都需要log n的时间。相比暴力方法,这在处理大规模数据时更高效。 最后,生成相关问题。根据用户之前的问题,可能需要关于优化、应用场景以及与其他数据结构的比较的问题。比如,二维树状数组二维线段树的区别,或者如何扩展到更高维度。 需要确保代码正确无误,并符合Python语法。同时,引用相关文献,比如引用2中的二维树状数组应用和引用4中的例题,来增强回答的可信度。还要注意用户的中文回答要求,保持结构清晰,分步骤解释。</think>### 二维树状数组实现与应用详解 #### 一、核心原理 二维树状数组是树状数据结构在二维空间的扩展,主要用于高效处理**子矩阵和查询**和**单点更新**。其核心原理基于二维二进制索引结构: 1. 每个节点存储特定子矩阵的和 2. 通过**lowbit(x)**运算确定覆盖范围 3. 时间复杂度:单次查询/更新 $O((\log n)^2)$ #### 二、Python实现代码 ```python class BinaryIndexedTree2D: def __init__(self, rows, cols): self.n = rows self.m = cols self.tree = [[0]*(cols+1) for _ in range(rows+1)] def update(self, x, y, delta): # 单点更新操作 i = x while i <= self.n: j = y while j <= self.m: self.tree[i][j] += delta j += j & -j i += i & -i def query(self, x, y): # 查询(1,1)到(x,y)的子矩阵和 res = 0 i = x while i > 0: j = y while j > 0: res += self.tree[i][j] j -= j & -j i -= i & -i return res def range_query(self, x1, y1, x2, y2): # 查询任意子矩阵和 return (self.query(x2, y2) - self.query(x1-1, y2) - self.query(x2, y1-1) + self.query(x1-1, y1-1)) ``` #### 三、典型应用场景 1. **动态矩阵求和**:实时更新矩阵元素值并查询子矩阵和 - 例:POJ 1195 Mobile phones[^4] 2. **二维偏序问题**:统计满足 $x_i < x_j$ 且 $y_i < y_j$ 的点对数量 3. **图像处理**:区域像素值统计与更新 4. **游戏地图**:动态更新地形数据并快速统计区域属性 #### 四、操作时间复杂度对比 | 操作类型 | 暴力方法 | 二维树状数组 | |----------------|------------|--------------| | 单点更新 | $O(1)$ | $O((\log n)^2)$ | | 子矩阵查询 | $O(n^2)$ | $O((\log n)^2)$ | | 区域更新+查询 | $O(n^2)$ | $O((\log n)^2)$ | #### 五、实战技巧 1. **坐标偏移**:当坐标从0开始时,统一+1转换为从1开始 2. **离散化处理**:当坐标范围过大时先进行离散化 3. **差分技巧**:处理区间更新操作 ```python # 给子矩阵(x1,y1)-(x2,y2)统一加delta bit.update(x1, y1, delta) bit.update(x1, y2+1, -delta) bit.update(x2+1, y1, -delta) bit.update(x2+1, y2+1, delta) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值