VOJ - Longest Chain （CDQ分治三维偏序）

Longest Chain

题目链接： Longest Chain Gym - 102014G

题意

给你一个N个三元组，定义三元组 $T_1>T_2$ 为 $x_1 > x_2 $ and $y_1>y_2$ and $z_1>z_2$ ,现在要这N个三元组中找到一个最长的序列满足每个后面的元素都大于前面的元素（注意不是子序列，是无序的）

数据范围： $N<3\ast 10^5$ , Time Limit : 60s.

---

思路

首先，既然有关于三维偏序的排序问题，那么肯定就离不开CDQ分治了。

CDQ分治的经典例题是求小于等于每个三元组的元素数

我们既然要套用那个模板就需要修改一些问题

原来的CDQ分治是可以不严格的，所以在完全相等的时候我们的操作是直接将其合并为一个节点。

一. cmp函数在第一比较元素相等时应该返回后面元素较大的

原来的CDQ分治是可以不严格的，所以在完全相等的时候我们的操作是直接将其合并为一个节点。

而现在不严格时，为了不让相同元素进行干扰，我们就让大的在前面，这样就一定不会有问题了。

二. 树状数组要修改

现在要求树状数组的功能时 $dp[i]=max(dp[j]|j<i)$ 这里求最大值是，把所有子节点的信息更新给父亲。父亲在查询时，查询自己所有子节点的最值。

三. CDQ分治顺序

时，因为这里是求最大值，而每次都需要清空数组，所以我们希望能先算前面的，在算完前面的后，在利用前面的信息更新后面的元素。

我们原先用的是后序遍历的分治，我们现在用了中序遍历。同时，如果我们使用了中序遍历，那么为了不影响后面的操作，我们又开了一个临时数组，来进行排序。

四. 排序

因为在对于每次分治区间时，我们都需要进行用树状数组来进行维护，总的复杂度为 $O(nlo{g}^{2}n)$ 所以我们不必再中规中矩的进行归并排序了，我们可以直接用sort函数。

---

代码

#include <bits/stdc++.h>
using namespace std;
#define rep(i,j,k) for(int i = (int)j;i <= (int)k;i ++)
#define debug(x) cerr<<#x<<":"<<x<<endl
#define pb push_back

typedef long long ll;
const int MAXN = (int)1e6+7;

template<typename T,size_t size>
struct BIT {
    T a[size]; int n;
    void init(int _n){n=_n;memset(a,0,sizeof(T)*(_n+1));}
    void erase(int x){      for(int i=x;i<=n;i+=i&-i)a[i]=0; }
    void update(int x,T y){ for(int i=x;i<=n;i+=i&-i)a[i]=max(a[i],y);}
    T query(int x){T re=0;  for(int i=x;i;i-=i&-i)re=max(a[i],re);return re;}
};
BIT<int,MAXN>bit;

int m,N,A,B;
int a , b , C = ~(1<<31), M = (1<<16)-1;
int r() {
    a = 36969 * (a & M) + (a >> 16);
    b = 18000 * (b & M) + (b >> 16);
    return (C & ((a << 16) + b)) % 1000000;
}

struct Node {
    int x,y,z,id;
}e[MAXN],te[MAXN];

bool cmpX (const Node&a,const Node&b) { return a.x==b.x?(a.y==b.y?a.z>b.z:a.y>b.y):a.x < b.x;}
bool cmpY (const Node&a,const Node&b) { return a.y==b.y?a.z>b.z:a.y<b.y;}

int num[MAXN];

void meg(int l,int r) {
    if (l == r) return;
    int m = l+r>>1;
    meg(l,m);
    memcpy(te+l,e+l,sizeof(Node)*(r-l+1));
    sort(te+l,te+m+1,cmpY);
    sort(te+m+1,te+r+1,cmpY);

    int pl = l;
    rep(i,m+1,r) {
        while (pl <= m && te[pl].y < te[i].y && te[pl].x < te[i].x) bit.update(te[pl].z,num[te[pl].id]),pl++;
        num[te[i].id] = max(num[te[i].id],bit.query(te[i].z-1)+1);
    }
    rep(i,l,r) bit.erase(te[i].z);
    meg(m+1,r);
}

int main()
{
    while (~scanf("%d %d %d %d",&m,&N,&a,&b),m||N){
        bit.init(1000002);
        rep(i,0,m+N) num[i] = 1;
        rep(i,1,m) {
            int x,y,z;
            scanf("%d %d %d",&x,&y,&z);
            e[i] = (Node){x,y,z+1,i};
        }
        rep(i,m+1,m+N) {
            e[i].x = r();
            e[i].y = r();
            e[i].z = r()+1;
            e[i].id = i;
        }

        N = m+N;
        sort(e+1,e+1+N,cmpX);
        meg(1,N);

        //rep(i,0,N) cout << i << ":" << num[i] << endl;

        int ans = *max_element(num,num+1+N);
        printf("%d\n",ans);
    }
}