2253: [2010 Beijing wc]纸箱堆叠

2253: [2010 Beijing wc]纸箱堆叠

Time Limit: 30 Sec   Memory Limit: 256 MB
Submit: 375   Solved: 140
[ Submit][ Status][ Discuss]

Description

P 工厂是一个生产纸箱的工厂。纸箱生产线在人工输入三个参数 n p a , , 之后，
即可自动化生产三边边长为

(a mod P,a^2 mod p,a^3 mod P)
(a^4 mod p,a^5 mod p,a^6 mod P)
....
(a^(3n-2) mod p,a^(3n-1) mod p,a^(3n) mod p)

的n个纸箱。在运输这些纸箱时，为了节约空间，必须将它们嵌套堆叠起来。
一个纸箱可以嵌套堆叠进另一个纸箱当且仅当它的最短边、次短边和最长边
长度分别严格小于另一个纸箱的最短边、次短边和最长边长度。这里不考虑
任何旋转后在对角线方向的嵌套堆叠。 
你的任务是找出这n个纸箱中数量最多的一个子集，使得它们两两之间都可
嵌套堆叠起来。

Input

输入文件的第一行三个整数，分别代表 a,p,n  

Output

 
输出文件仅包含一个整数，代表数量最多的可嵌套堆叠起来的纸箱的个数。

Sample Input

10 17 4

Sample Output

2
【样例说明】
生产出的纸箱的三边长为(10, 15, 14), (4, 6, 9) , (5, 16, 7), (2, 3, 13)。其中只有
(4, 6, 9)可堆叠进(5, 16, 7)，故答案为 2。
2<=P<=2000000000,1<=a<=p-1,a^k mod p<>0,ap<=2000000000,1<=N<=50000

HINT

Source

[ Submit][ Status][ Discuss]



要求三位偏序，如果先将所有长方体按照a,b,c升序三关键字排好

考虑从左往右，每个长方体能接受的贡献就是b,c都严格小于他的，放在二维坐标系上就是一个矩形

可以用动态开点的二维线段树维护O(nlog^2n)

不过此题可用CDQ分治做掉= =

先对所有矩形按照a升序排好，在处理[l,mid]对[mid+1,r]的贡献的时候

先让两边的点按照b升序排好，要处理右边的第k个点时，让左边b小于它的都进入树状数组维护

单次查询就是O(logn)，不过树状数组常数很小的

虽然理论复杂度不变，不过这个是比二维线段树小很多常数的算法= =

但是还是WA飞啊。。。惨

CDQ分治一定要先让左区间给右区间贡献，然后才能往右递归

排序有很多次。。顺序不能乱= =

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;

const int maxn = 5E4 + 50;
typedef long long LL;

struct data{
	int a,b,c,num; data(){}
	data(int a,int b,int c): a(a),b(b),c(c){}
}D[maxn];

int n,x,cur,Cur,Ans,A[3],Max[maxn],L[maxn],R[maxn],ma[maxn],Num[maxn];
LL p;

int Mul(const LL &x,const LL &y) {return x*y%p;}
bool cpa(const data &x,const data &y) {return x.a < y.a;}
bool cpb(const data &x,const data &y) {return x.b < y.b;}

void Discretization(int l,int r)
{
	int tot = 0; Cur = 1;
	for (int i = l; i <= r; i++) Num[++tot] = D[i].c;
	sort(Num + 1,Num + tot + 1);
	for (int i = 2; i <= tot; i++)
		if (Num[i] != Num[i-1]) Num[++Cur] = Num[i];
	for (int i = 1; i <= Cur; i++) ma[i] = 0;
}

void Insert(int k)
{
	int pos = lower_bound(Num + 1,Num + Cur,D[k].c) - Num;
	for (int j = pos; j <= Cur; j += j&-j)
		ma[j] = max(ma[j],Max[D[k].num]);
}

int Query(int k)
{
	int pos = lower_bound(Num + 1,Num + Cur,D[k].c) - Num,ret = 0;
	for (int j = pos - 1; j > 0; j -= j&-j)
		ret = max(ret,ma[j]);
	return ret;
}

void Solve(int l,int r)
{
	if (l == r)
	{
		sort(D + L[l],D + R[r] + 1,cpb);
		for (int i = L[l]; i <= R[r]; i++) 
			if (!Max[D[i].num]) Max[D[i].num] = 1; return;
	}
	int mid = (l + r) >> 1; Solve(l,mid);
	sort(D + L[mid+1],D + R[r] + 1,cpb);
	Discretization(L[l],R[r]);
	int pos = L[l];
	for (int i = L[mid+1]; i <= R[r]; i++)
	{
		while (pos <= R[mid] && cpb(D[pos],D[i])) Insert(pos++);
		int ret = Query(i);
		Max[D[i].num] = max(Max[D[i].num],ret + 1);
	}
	sort(D + L[mid+1],D + R[r] + 1,cpa); Solve(mid + 1,r);
	sort(D + L[l],D + R[r] + 1,cpb);
}

int main()
{
	#ifdef DMC
		freopen("DMC.txt","r",stdin);
	#endif
	
	cin >> x >> p >> n; int z = x;
	for (int i = 1; i <= n; i++)
	{
		A[0] = x; A[1] = Mul(x,z); 
		A[2] = Mul(A[1],z); x = Mul(A[2],z);
		sort(A,A + 3);
		D[i] = data(A[0],A[1],A[2]);
	}
	sort(D + 1,D + n + 1,cpa);
	for (int i = 1; i <= n; i++)
	{
		if (D[i].a != D[i-1].a) 
			R[cur++] = i - 1,L[cur] = i;
		D[i].num = i;
	}
	R[cur] = n; Solve(1,cur);
	for (int i = 1; i <= n; i++) Ans = max(Ans,Max[i]);
	cout << Ans;
	return 0;
}