陌上开花（三维偏序例题，本人借鉴的二维分块实现，也可看作二维分块实现）

#include <iostream>
#include <vector>
using namespace std;

/*
二维分块的做法是，首先将每一维坐标离散化为一个排列，此时横坐标 x 和纵坐标 y 是唯一对应的，这样就可以暴力统计一个矩形中散块部分的答案，其复杂度与矩形最短边的长度同阶。

然后用二维树状数组处理整块部分，树状数组维护的二维平面上每个位置的值是对应整块内所有元素的和。设块长为 B，则空间复杂度为 O(n + (n/B)^2)。

修改时，在树状数组上更新对应的整块位置，同时更新单点信息；查询时，在树状数组上查询对应的前缀整块和，再暴力统计散块部分。这样总时间复杂度是 O(n log^2 (n/B) + nB)。

如果取 B = log^2 n，时间复杂度为 O(n log^2 n)，空间复杂度为 O(n^2 / log^4 n)
*/

const int N = 1e5 + 5, M = 2e5 + 5, B = 200, S = N / B + 5;
int n, k, a[N], b[N], c[N], la[M], ra[M], lb[M], rb[M], ab[N], ba[N], bel[N], va[N], vb[N], t[S][S],ans[N];
vector<pair<int, int>> valu[M], ques[M];

int lowbit(int x) {
	return x & (-x);
}

void _update(int x, int y) {
	for (int i = x; i <= bel[n]; i += lowbit(i))
		for (int j = y; j <= bel[n]; j += lowbit(j)) ++t[i][j];
}

int _query(int x, int y) {
	int ret = 0;
	for (int i = x; i >= 1; i -= lowbit(i))
		for (int j = y; j >= 1; j -= lowbit(j)) ret += t[i][j];
	return ret;
}

void update(int x, int y) { 
	_update(bel[x], bel[y]);
	++va[x];//此处横坐标上点的数量
	++vb[y];//同理
}

int query(int x, int y) {
	int ret = _query(bel[x] - 1, bel[y] - 1);//整块查询
	//以下为散块查询
	for (int i = B * (bel[x] - 1) + 1; i <= x; i++)
		if (ab[i] <= y) ret += va[i];//如果此处的x轴上有点且该点的纵坐标在范围内，那么纳入统计
	for (int i = B * (bel[y] - 1) + 1; i <= y; i++)
		if (ba[i] <= B * (bel[x] - 1)) ret += vb[i];//同理
	return ret;
	/*
	为什么这段条件不对称？
	考虑将查询区域的x，y各分成两段，那么一共有4个区域
	分别是横纵坐标皆为整块的区域A，横坐标完整块纵坐标为不完整块的区域B，横坐标不完整快纵坐标完整快的区域C，横纵坐标皆为不完整快的区域D
	区域A已经被整块查询解决，区域C，D已经被散块查询的第一条循环语句解决，为了避免重复统计区域D，所以条件会不对称
	*/
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
	cin >> n >> k;
	for (int i = 1; i <= n; i++) {
		cin >> a[i] >> b[i] >> c[i];
		++ra[a[i]], ++rb[b[i]];
	}
	for (int i = 1; i <= k; i++) {
		la[i] = ra[i - 1] + 1;
		ra[i] += ra[i - 1];
		lb[i] = rb[i - 1] + 1;
		rb[i] += rb[i - 1];
	}
	//初步确定值相同元素的排名
	
	for (int i = 1; i <= n; i++) {
		int x = la[a[i]]++, y = lb[b[i]]++;
		ab[x] = y, ba[y] = x;
		//映射与反映射
		valu[c[i]].emplace_back(x, y);
		ques[c[i]].emplace_back(ra[a[i]], rb[b[i]]);
	}
	//按照c[i]的顺序给a[i]和b[i]确定唯一的排名
		
	for (int i = 1; i <= n; i++) bel[i] = (i - 1) / B + 1;
	for (int i = 1; i <= k; i++) {
		for (auto [x, y] : valu[i]) update(x, y);
		for (auto [x, y] : ques[i]) ++ans[query(x, y) - 1];
		//query(x,y)返回[1,x][1,y]之间的点的数量，因为题目要求j≠i，所以要-1
	}
	for (int i = 0; i < n; i++) cout << ans[i] << '\n';
	
	return 0;
}