CDQ分治解决三维偏序问题

CDQ 分治

二元关系

有两个集合 $A$, $B$, 他们的笛卡尔积 $A \times B$ 是 $|A|\times|B|$ 个点对构成的集合, 即 $A$ 中的每个元素和 $B$ 中每个元素组成的有序点对.

定义 $A \times B$ 的一个子集 $R$, 则 $R$ 是 $A$ 和 $B$ 的一个二元关系.

偏序

偏序也是一种二元关系, 设一个定义在同一个集合 $A$ 中的二元关系 $R \in A \times A$, 满足以下性质:

• 自反性

  对于每个元素 $a \in A$ 有 $(a, a) \in R$.

• 反对称性

  如果存在 $(a, b) \in R$ 且 $(b, a) \in R$, 则 $a = b$.

• 传递性

  如果存在 $(a, b) \in R$ 且 $(b, c) \in R$, 则 $(a, c) \in R$.

则 $R$ 是一个偏序.

如果 $R$ 还满足:

• 完全性

  对于每一个 $a \in A$, $b \in A$, 一定有 $(a, b) \in R$ 或 $(b, a) \in R$.

则 $R$ 是一个全序.

一般我们说的偏序都是非严格偏序 (自反偏序), 但是与之相对, 有一种严格偏序 (反自反偏序), 严格偏序在满足传递性的基础上, 满足:

• 反自反性

  对于每个元素 $a \in A$ 不存在 $(a, a) \in R$.

• 禁对称性

  如果存在 $(a, b) \in R$ 则不存在 $(b, a) \in R$.

其实对于每个严格偏序中的点对, 在对应的非严格偏序中一定存在, 如果每个点对表示一条有向边, 则严格偏序一定对应一个 DAG, 而非严格偏序中会增加一些自环和重边.

算法竞赛中的题目, 一般偏序的要求是满足反自反性, 对称性和传递性.

二维偏序

如果有有序二元组 $(a, b)$ 构成的集合 $A$, 则一个有序二元组的有序点对 $R \in A \times A$ 就是一个二维偏序.

如果规定 $((a_i, b_i), (a_j, b_j)) \in R$, 当且仅当 $a_i \leq a_j$ 且 $b_i \leq b_j$, 求 $|R|$, 这就是一道很简单的二维偏序题.

很幸运, 二维偏序一般不需要 CDQ 分治, 只要对所有二元组按 $a$ 为第一关键字, $b$ 为第二关键字排序, 然后建立树状数组, 从第一个开始, 依次查询 $[1, b_i]$ 的 $b$ 的数量, 然后插入 $b_i$ 即可.

高端的食材, 往往只需要采用最朴素的烹饪方式.

但是, 我们使用同样高端的烹饪方式又有何不可?

尝试用 CDQ 分治解决二维偏序.

已经按 $a$ 第一, $b$ 第二排好序了, 将所有二元组分成左右两部分, $[1, Mid]$, $(Mid, n]$. 这时, 满足 $((a_i, b_i), (a_j, b_j)) \in R$ 的 $i$, $j$ 有三种情况:

• $i \in [1, Mid]$, $j \in (Mid, n]$

• $i \in [1, Mid]$, $j \in [1, Mid]$

• $i \in (Mid, n]$, $j \in (Mid, n]$

对于第一种情况, 按 $b$ 可以用双指针 $O(n)$ 求出, 对于后两种, 可以递归解决, 总复杂度还是 $O(nlogn)$.

这种双指针 + 递归的分治思想是不是非常眼熟? 没错, 这就是归并排序的加强版.

三维偏序

同理, 如果有有序三元组 $(a, b, c)$ 构成的集合 $A$, 定义 $R \in A * A$, 当前仅当 $a_i \leq a_j$, $b_i \leq b_j$, $c_i \leq c_j$ 同时成立时, $((a_i, b_i, c_i), (a_j, b_j, c_j)) \in R$. 求 $|R|$.

很显然, 这是一道三维偏序题, 仍然是先按 $a$ 排序. 然后分成两部分, 还是存在那三种情况.

• $i \in [1, Mid]$, $j \in (Mid, n]$

• $i \in [1, Mid]$, $j \in [1, Mid]$

• $i \in (Mid, n]$, $j \in (Mid, n]$

仍然思考如何求出第一种情况数量. 因为已知 $a_i \leq a_j$, 所以相当于在 $A$ 的子集 $B$, $C$ (即左右两段的点代表的集合), 求二维偏序 $R \in B \times C$ 的 $|R|$.

参考二维偏序的做法, 对于左右两段分别按 $b$ 排序, 双指针 $i$, $j$ 扫描, 使得 $b_i = b_j$. 然后不断将左段的 $c_i$ 加入树状数组, 然后查询 $[1, c_j]$ 的数量, 统计答案, 然后递归求子问题.

参考前面 CDQ 分治求二维偏序, 发现三维偏序用 CDQ 转化来的二维偏序问题也可以用 CDQ 分治再来一层.

在左段打标记, 然后将所有三元组按 $b$ 排序. (貌似只能 cmp() 函数解决了, 二次重载运算符是被禁止的) (在张业琛的提醒下, 在 std=c++11 的情况下, 可以使用 Lambda 表达式来代替 cmp())

这时, 按二维偏序来做, 但是左边只考虑有标记的点, 右边只考虑无标记的点. 递归到底就求出了上面分的三种情况中的第一种, 剩下的仍然递归求出, 总复杂度 $O(nlog^2n)$.

多维偏序

用上面的方法, 可以推广到 $k$ 维, 但是时间复杂度 $O(nlog^{k - 1}n)$ 在 $1s$ 内能解决的问题的规模, 越来越接近朴素的 $O(kn^2)$ 甚至更劣. 所以一般到了 $4$ 维, CDQ 分治就没什么意义了.

模板

三维偏序计数题, 求对于每一个 $i$, 满足 $a_j \leq a_i$, $b_j \leq b_i$, $c_j \leq c_i$, $j \neq i$ 的 $j$ 的数量.

索性用一维排序, 二维 CDQ, 三维树状数组的逻辑来做好了.

按 $a$ 排序, 进入 CDQ.

CDQ 分成两段, 段内按 $b$ 排序, 然后树状数组统计, 然后递归之前再按 $a$ 排序.

最后递归求其它情况.

#define Lowbit(x) ((x) & (-(x)))
unsigned m, n, NM(0), A, B, C, D, t, Tree[200005], Ans[100005];
inline unsigned Qry(unsigned Pos) {
  unsigned TmpQ(0);
  while (Pos) TmpQ += Tree[Pos], Pos -= Lowbit(Pos);
  return TmpQ;
}
inline void Add(unsigned Pos, unsigned Val) {while(Pos <= m) Tree[Pos] += Val, Pos += Lowbit(Pos);}
inline void Minus(unsigned Pos, unsigned Val) {while(Pos <= m) Tree[Pos] -= Val, Pos += Lowbit(Pos);}
struct Group {
	unsigned a, b, c, Cnt, Same;
	inline const char operator<(const Group &x) {return this->b < x.b;}
}G[100005];
inline const char cmp(const Group &x, const Group &y) {return (x.a ^ y.a) ? (x.a < y.a) : ((x.b ^ y.b) ? (x.b < y.b) : (x.c < y.c));}
void CDQ(unsigned L, unsigned R) {
  if(L == R) return; 
  register unsigned Mid((L + R) >> 1);
  CDQ(L, Mid);
  CDQ(Mid + 1, R);
  sort(G + L, G + Mid + 1);
  sort(G + Mid + 1, G + R + 1);
  register unsigned PointerL(L), PointerR(Mid + 1);
  while (PointerR <= R) {
    while (G[PointerL].b <= G[PointerR].b && PointerL <= Mid) Add(G[PointerL].c, G[PointerL].Same), ++PointerL;
    G[PointerR].Cnt += Qry(G[PointerR].c), ++PointerR;
  }
  while (PointerL > L) --PointerL, Minus(G[PointerL].c, G[PointerL].Same);
}
int main() {
	n = RD(), m = RD();
	for (register unsigned i(1); i <= n; ++i) G[i].a = RD(), G[i].b = RD(), G[i].c = RD();
	sort(G + 1, G + n + 1, cmp);
	for (register unsigned i(1); i <= n; ++i) {if((G[i].a ^ G[i - 1].a) || (G[i].b ^ G[i - 1].b) || (G[i].c ^ G[i - 1].c)) G[++NM] = G[i]; ++(G[NM].Same);}
  CDQ(1, NM);
	for (register unsigned i(1); i <= NM; ++i) Ans[G[i].Cnt + G[i].Same - 1] += G[i].Same;
	for (register unsigned i(0); i < n; ++i) printf("%u\n", Ans[i]);
	return Wild_Donkey;
}

有一些细节需要注意: 排序的规则方面, 按 $a$ 排序的时候, 必须保证不能存在 $i > j$, $(i, j) \in R$ 存在, 这就要求必须分别按 $a$, $b$, $c$ 为第一, 二, 三关键字排序. 而按 $b$ 排序的时候, 只需要保证两段中, $b$ 值单调递增即可, 所以根本不需要第二, 第三关键字.