[JZOJ5608]【NOI2018模拟3.28】Subset

Description

给出三个1到N的排列a,b,c
称三元组(a,b,c)是合法的，当且仅当存在一个下标集合S
满足$(x,y,z)=(max_{i\in S}a[i],max_{i\in S}b[i],max_{i\in S}c[i])$
N<=100000

Solution

我们不妨只考虑最简的集合S，就是集合中每个下标位置至少占a,b,c中的一个

那么|S|只有三种，1，2，3

|S|=1显然这样合法的集合有N种

|S|=2除了最大值都被一个位置占了的都是合法的
可以将第一维排序，然后对这维CDQ分治，[l,mid],[mid+1,r]分别对第二维排序，用两个指针向后扫，第三维再用树状数组统计，这样复杂度是$O(N\log^2N)$的

考虑|S|=3
正着考虑比较麻烦，我们可以用总的减去不合法的
不合法有两种，一种是三个最大值都被一个位置占了，一种是两个最大值被一个位置占了，另一个最大值在别的位置

第一种可以很容易用|S|=2已经计算出来的东西解决，设它总数为A
第二种似乎不那么好办，先设它总数为B

我们先求出两维最大值被一个位置占了，剩下一维不知道在哪里的总数，设它为X
这可以排序扫一遍树状数组维护
容易发现X=3*A+B（因为剩下一维可能也是这个位置，这样会被算三次）

那么就可以算出B
进而就能算出所有的答案了

总的复杂度是$O(N\log^2N)$

Code

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <cstring>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;++i)
#define fod(i,a,b) for(int i=a;i>=b;--i)
#define N 100005
#define LL long long
using namespace std;
int n;
struct node
{
    int x,y,z;  
    friend bool operator <(node x,node y)
    {
        return x.x<y.x;
    }
}a[N];
int w[N],c[N];
bool bz[N];
LL ans,s1[N],s2,s3;
int lowbit(int k)
{
    return (k&(-k));
}
void put(int k,int v)
{
    while(k<=n) c[k]+=v,k+=lowbit(k);
}
int get(int k)
{
    int s=0;
    while(k>0) s+=c[k],k-=lowbit(k);
    return s;
}
bool cmp(int x,int y)
{
    return a[x].y<a[y].y;
}
void doit(int l,int r)
{
    if(l==r) return;
    int mid=(l+r)/2;
    fo(i,l,r) w[i]=i;
    sort(w+l,w+mid+1,cmp),sort(w+mid+1,w+r+1,cmp);
    int j=l;
    fo(i,mid+1,r)
    {
        while(j<=mid&&a[w[j]].y<a[w[i]].y) put(a[w[j]].z,1),j++;
        s1[w[i]]+=get(a[w[i]].z);
    }
    fo(i,l,j-1) put(a[w[i]].z,-1);
    doit(l,mid),doit(mid+1,r);
}
void find()
{
    memset(c,0,sizeof(c));
    fo(i,1,n)
    {
        LL v=get(a[i].y-1);
        s3+=v*(v-1)/2;
        put(a[i].y,1);
    }
}
int main()
{
    cin>>n;
    fo(i,1,n) scanf("%d",&a[i].x);
    fo(i,1,n) scanf("%d",&a[i].y);
    fo(i,1,n) scanf("%d",&a[i].z);
    sort(a+1,a+n+1);
    ans=n;
    s2=(LL)n*(LL)(n-1)/2,s3=0;
    doit(1,n);
    fo(i,1,n) s2-=s1[i];
    ans+=s2;
    s2=0;
    fo(i,1,n) s2+=s1[i]*(s1[i]-1)/2;
    find();
    fo(i,1,n) swap(a[i].x,a[i].z);
    sort(a+1,a+n+1);
    find();
    fo(i,1,n) swap(a[i].y,a[i].z);
    sort(a+1,a+n+1);
    find();
    s3=s3-3*s2;
    ans+=(LL)n*(LL)(n-1)*(LL)(n-2)/6-s3-s2;
    printf("%lld\n",ans);
}