算法进阶

Posted 2021-03-12 zhuier-xquan

树状数组

略

---

求一个数组(A_1,A_2……A_n)的逆序对数（树状数组做

(n ≤ 100000, |A_i| ≤ 10^9)

我们将(A_1, ..., A_n)按照大小关系变成(1...n).这样数字的大小范围在([1, n])中.（离散化）
从左往右动态维护一个数组(B_i),表示扫描到当前位置有多少个数的大小正好是(i)
从左往右扫描每个数,对于(A_i),累加(B_{A_i+1}...B_n)的和,同时将(B_{Ai})加(1).
时间复杂度为(O(N log N)).

链接

分治进阶

(CDQ)分治

(CDQ)分治的思想是用一个子问题来计算对另一个子问题的贡献。
我们注意到在分治的过程中,与(i)无关的([1,i-1])和([i+1,n])会由于分割而慢慢地被分离开。对于j对i的贡献，我们在(j)与(i)被分开的时候去计算.
我们要解决一系列问题，这些问题一般包含修改和查询操作，可以把这些问题排成一个序列，用一个区间([L,R])表示。
分。递归处理左边区间([L,M])和右边区间([M+1,R])的问题。
治。合并两个子问题，同时考虑到([L,M])内的修改对([M+1,R])内的查询产生的影响。即，用左边的子问题帮助解决右边的子问题。 　　
这就是(CDQ)分治的基本思想。和普通分治不同的地方在于，普通分治在合并两个子问题的过程中，([L,M])内的问题不会对([M+1,R])内的问题产生影响。

---

三维(LIS)

给定数组(A, B,)求最长的子序列,满足(?i < j,A_i<A_j,B_i<B_j)

(N ≤ 100000)

分治+树状数组+(dp)

(f[i])表示到(i)为止的最长上升子序列，则(f[i]=max_{j<i,A_j<A_i,B_j<B_i}f[j]+1)，分治寻找最大的(j)：

将一个大的区间拆解为两个小区间，先递归处理左区间，然后通过左区间修改右区间，接着再递归处理右区间：

(1.)前提是左区间的(f[i])都已经处理好了

(2.)我们将左右区间按照(A[i])升序排列

(3).那么对于右区间的一个(A[i])，我们一定可以找到一个从左区间左侧开始连续的一段区间，这段区间的每一个(A[j])都满足(A[j]<A[i]);

(4).然后将所有满足的(A[j])的相关信息放入一个树状数组中：

树状数组中以(B[])的值为下标（这里假装离散化过），以(f[])的值为树状数组维护的权值

(5.)如何求得(f[i])：在树状数组中寻找最大的下标在(1)~(B[i]-1)之间的(f[j])，更新(f[i])

(6.)不要着急：为了做到树状数组重复使用，记得每次清空树状数组

(CODE from fz:)

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<ctime>
#include<set>
#include<vector>
#include<map>
#include<queue>

#define N 300005
#define M 8000005

#define ls (t<<1)
#define rs ((t<<1)|1)
#define mid ((l+r)>>1)

#define mk make_pair
#define pb push_back
#define fi first
#define se second

using namespace std;

int i,j,m,n,p,k,f[N],tree[N],id[N],a[N],b[N];

inline int cmp(int x,int y)
{
        return a[x]<a[y];
}

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

void ins(int x,int y)
{
        for(;x<=n;x+=lowbit(x)) tree[x]=max(tree[x],y); 
}

void Clear(int x)
{
        for(;x<=n;x+=lowbit(x)) tree[x]=0; 
}   

int ask(int x)
{
        int s=0;
        for (;x;x-=lowbit(x)) s=max(s,tree[x]);
        return s;
}

void Work(int l,int r)
{
        if (l==r) f[l]+=1;
        else
        {
                Work(l,mid);
                for (i=l;i<=r;++i) id[i]=i;
                sort(id+l,id+mid+1,cmp);
                sort(id+mid+1,id+r+1,cmp);
                int L=l;
                for (i=mid+1;i<=r;++i)
                {
                        int p=id[i];
                        while (L<=mid&&a[p]>a[id[L]]) ins(b[id[L]],f[id[L]]),++L;
                        f[p]=max(f[p],ask(b[p]-1));
                }
                for (i=l;i<=mid;++i) Clear(b[id[L]]);
                Work(mid+1,r);
        }
}

int main()
{
        scanf("%d",&n);
        for (i=1;i<=n;++i) scanf("%d",&a[i]);
        for (i=1;i<=n;++i) scanf("%d",&b[i]);
        Work(1,n); 
        for (i=1;i<=n;++i)f[0]=max(f[0],f[i]);
        printf("%d
",f[0]);
}

整体二分

区间第K大值

给定长度为(N)的序列(A,Q)组询问，每组询问给出(li,ri, ki),询问第(li)个数到第(ri)个数之间第(ki)大的值是多少。
(N, Q ≤ 100000, |Ai| ≤ 10^9)

二分第(K)大值为(mid),判断区间([l,r])中(geq mid)的数的个数(ans)，如果(ans< ki),则说明答案在([-∞,mid])之间，否则在([mid,+∞])之间。

现在考虑怎么快速计算(geq mid)的个数:

一个显然的想法是我们每次找出大于mid的所有数，然后排序之后通过两次二分找到([l,r])用新数组的下标就可以得到答案了:如下：

然后：???????

分块

Counter

给出一个长度为(N)的整数序列(A),有(Q)组询问，第(i)组询问给出(li,ri),询问(li)到(ri)之间有多少个不同的数.
(N ≤ 100000)

首先我们对整个序列进行离散化，使得所有的数都落在(1)到(N)之内。然后对序列分块
我们先预处理第一个信息，令(F_{i,j})表示前(i)块里面，数字(j)出现的次数.
然后我们考虑一个(G_{i,j}),表示第(i)块到第(j)块里不同数字的个数。那么(G_{i,j} = G_{i,j?1} + Work(i, j ? 1, j).)
其中(Work(i, x, y))表示的是在第(i)块到第(x)块的末尾加入第(y)块增加的不同数个数。

(CODE from fz:)

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<ctime>
#include<set>
#include<vector>
#include<map>
#include<queue>

#define N 300005
#define M 8000005

#define ls (t<<1)
#define rs ((t<<1)|1)
#define mid ((l+r)>>1)

#define mk make_pair
#define pb push_back
#define fi first
#define se second

using namespace std;

int i,j,m,n,p,k,ans,a[N],S;

int main()
{
        scanf("%d",&n);
        for (i=1;i<=n;++i) scanf("%d",&a[i]);
        int S=(int)sqrt(n);
        for (i=1;i<=n;i=ed[tot]+1)
        {
                st[++tot]=i;
                ed[tot]=min(n,i+S-1);
        }
        for (i=1;i<=tot;++i) //sqrt(n) 
        {
                for (j=1;j<=n;++j) F[i][j]=F[i-1][j]; //O(n) 
                for (j=st[i];j<=ed[i];++j) F[i][a[j]]++; //sqrt(n)
        }
        //[i..j-1] a[k] F[j-1][a[k]]-F[i-1][a[k]]
        for (i=1;i<=tot;++i) //sqrt(n)
            for (j=i;j<=tot;++j) //sqrt(n)
            {
                    G[i][j]=G[i][j-1]; 
                    for (k=st[j];k<=ed[j];++k) //sqrt(n) 
                        if (!(F[j-1][a[k]]-F[i-1][a[k]])&&!vis[a[k]]) G[i][j]++,vis[a[k]]=1;
                    for (k=st[j];k<=ed[j];++k) vis[a[k]]=0;
            }
        for (Q=1;Q<=m;++Q)
        {
                scanf("%d%d",&l,&r);
                int left=1,right;
                //[left,right] 
                if (r-l<=2*S)
                {
                        baoli(l,r);
                        continue;
                }
                while (st[left]<l) ++left;
                while (ed[right]<=r) ++right; --right;
                ans=G[left][right];
                for (i=st[left]-1;i>=l;--i)
                {
                        if (!(F[right][a[i]]-F[left-1][a[i]])&&!vis[a[i]]) ans++,vis[a[i]]=1;
                }
                for (i=ed[right]+1;i<=r;++i)
                {
                        if (!(F[right][a[i]]-F[left-1][a[i]])&&!vis[a[i]]) ans++,vis[a[i]]=1;
                } 
                printf("%d
",ans);
                for (i=st[left]-1;i>=l;--i)
                {
                        vis[a[i]]=0;
                }
                for (i=ed[right]+1;i<=r;++i)
                {
                        vis[a[i]]=0;
                } 
        }
}

基础莫队

莫队常用于各种区间相关的离线问题，其本质非常的暴力.

我们现在有一个区间([L, R])的答案，并且维护了这个区间的一些信息，现在我们要改求([L′, R′])的答案。
那很简单，只要我们暴力的把(L)一步一步地移动到(L′),再把(R)一步一步移动到(R′)就可以辣.
但是如果我们直接暴力总复杂度肯定不对，所以要求离线，用一些分析去把复杂度降低.在之后的讨论里，我们认为序列长度N和询问次数(Q)是同阶的.

(HH)的项链

给出一个长度为(N)的整数序列(A),有(Q)组询问，第(i)组询问给出(l_i,r_i),询问(l_i)到(r_i)之间有多少个不同的数.
(N ≤ 100000.)

1.离散化

2.序列维护每种数在([L, R])里面出现了多少次，当左右端点移动时，如果要加入一个数就对应加，否则对应减.当(cnt)加(1)变成(1)时，就把(Ans)加(1)，当(cnt[x])减(1)变成(0)时，就把(Ans)减(1).

如何来调整区间访问顺序使得总变化次数较少?

我们将序列按(sqrt N)分块，然后所有的询问先按照左端点所在的块排序，如果左端点所在块相同就按照右端点从小往大排序，这样就可以了.

我们分析移动次数。左端点的移动次数，如果是在同一块内，则单次不超过(sqrt N),否则如果是跨块，由于这样的次数不超过(sqrt N)次，则总复杂度不超过(Nsqrt N).
对于右端点，在每一块都会至多花费(O(N))的时间从头扫到尾再从尾扫到头，这个时候总复杂度为(O(Nsqrt N)).

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<ctime>
#include<set>
#include<vector>
#include<map>
#include<queue>

#define N 300005
#define M 8000005

#define ls (t<<1)
#define rs ((t<<1)|1)
#define mid ((l+r)>>1)

#define mk make_pair
#define pb push_back
#define fi first
#define se second

using namespace std;

int i,j,m,n,p,k,ansl,ansr,S,Sum[N],Ans[N],Block,A[N],l,r;

struct Node{
        int l,r,id;
}Q[N];

void Add(int x)
{
        Sum[x]++;
        if (Sum[x]==1) S++;
}

void Del(int x)
{
        Sum[x]--;
        if (Sum[x]==0) S--;
}

inline int cmp(Node a,Node b)
{
        if ((a.l-1)/Block!=(b.l-1)/Block) return a.l/Block<b.l/Block;
        return a.r<b.r;
}

int main()
{
        scanf("%d%d",&n,&m);
        for (i=1;i<=n;++i) scanf("%d",&A[i]);
        Block=(int)sqrt(n);
        ansl=ansr=1; S=1;
        for (i=1;i<=m;++i) scanf("%d%d",&Q[i].l,&Q[i].r),Q[i].id=i;
        sort(Q+1,Q+m+1,cmp);
        for (i=1;i<=m;++i)
        {
                l=Q[i].l,r=Q[i].r;
                while (ansl>l) --ansl,Add(A[ansl]);
                while (ansr<r) ++ansr,Add(A[ansr]);
                while (ansl<l) Del(A[ansl]),++ansl;
                while (ansr>r) Del(A[ansr]),--ansr;
                Ans[Q[i].id]=S;
        }
}
#include<bits/stdc++.h>

using namespace std;

inline int read() {
    int ans=0;
    char last=' ',ch=getchar();
    while(ch>'9'||ch<'0') last=ch,ch=getchar(); 
    while(ch>='0'&&ch<='9') ans=(ans<<1)+(ans<<3)+ch-'0',ch=getchar();
    if(last=='-') ans=-ans;
    return ans;
}const int mxn=1000010;

int n,m,B,Ans;
int a[mxn];
int cnt[mxn],ANS[mxn];

struct node {
    int l,r,id;
}b[mxn];

bool cmp(node a,node b) {
    if((a.l-1)/B!=(b.l-1)/B) 
        return a.l<b.l;
    return a.r<b.r;
}

void Add(int x) {
    cnt[x]++;
    if(cnt[x]==1) Ans++;
}

void Delete(int x) {
    cnt[x]--;
    if(cnt[x]==0) Ans--;
}

int main() {
    n=read();
    for(int i=1;i<=n;i++) 
        a[i]=read();
    B=sqrt(n);
    m=read();
    for(int i=1;i<=m;i++) {
        b[i].l=read();
        b[i].r=read();
        b[i].id=i;
    }
    sort(b+1,b+m+1,cmp);
    int L=1,R=1;Ans=1;cnt[a[1]]++;
    for(int i=1,l,r;i<=m;i++) {
        l=b[i].l;r=b[i].r;
        while(L<l) Delete(a[L]),L++;
        while(R>r) Delete(a[R]),R--;
        while(L>l) L--,Add(a[L]);
        while(R<r) R++,Add(a[R]);
        ANS[b[i].id]=Ans;
    }
    for(int i=1;i<=m;i++)
        printf("%d
",ANS[i]);
    return 0;
}

区间第(K)大？？？？

给出一个序列(A,Q)次询问，每次询问在([Li, Ri])中第(K)大的数是多少.(N, Q ≤ 100000,)为了方便，之后的题目中序列数值大小总不超过(N).
(N, Q ≤ 100000.)

(gugugu)

区间(mex)

给出一个序列(A,Q)次询问，每次询问在([Li, Ri])的(mex)是多少.
(N, Q ≤ 100000.)
一堆数的(mex)指的是不在这些数里出现的最小的自然数.

维护每个数的出现次数，询问的时候从小往大依次判断每个块是否是满的，如果不是满的则暴力扫描.然后从0开始暴力扫描第一个为0的出现次数，即为([L_i,R_i])的(mex)

总复杂度为(O(Nsqrt N).mex)这个东西是非常有用的.

树上莫队

反 正 我 没 听 懂