线段树专题-等差子序列 BZOJ-2124

线段树专题-等差子序列

感谢

感谢孙耀峰的线段树PPT,使我获益匪浅.

题目来源

$BZOJ-2124$

题意

给出长度为$n$的$1-n$的排列$A$
问是否存在一组$1\le p_1\le p_2\le ...\le p_l\le n,l\ge 3$
使得$A_{p1},A_{p2},...,A_{pl}$构成等差序列
数据范围$n\le 10^4$

题解

只要能形成长度为$3$的等差子序列,就直接输出$Yes$即可.

即需要寻找$i,j,k$满足$A_i=A_j-t,A_k=A_j+t,且t>0.$

根据转化后的式子,我们只需要枚举$j$,判断是否存在这样的$t$即可.

考虑到$A$是一个排列,排列中的数两两不同,因此我们可以考虑开一个数据结构维护一下内容:

当枚举到$A_j$的时候,我可以很快的查询任何一个$A_i$在$A_j$的左边还是右边,(记如果$i<j$则$A_j$应该标记为$0$表示在左边,若$i>j$则$A_j$应该标记为$1$表示在右边).

这样的话,如果$01$串$[A_j-t,A_j-1]$与$[A_j+1,A_j+t]$之间有一位不相同(也就是说存在关于$A_j$的对称位置的两个数在$A_j$两侧,说明可以形成等差子序列).

因此只有当以上两个01串,翻转过来完全相同的情况下,才不存在以$A_j$作为中心的等差序列.

如何判断$01$串相同呢?答案是哈希.

建立一颗线段树,维护的是$01$串的正向和反向哈希值.

从小到大枚举$A_j,[1,n]$,然后更新线段树,并判断是否有以$A_j$为对称中心的等差序列.

代码

#include <iostream>
#include <cstring>
const int N = 10007;
typedef unsigned long long ull;
int T,n;
int a[N];
 
ull pow[N];
struct work{
    ull hash0,hash1;
    int len;
};
 
#define pr(x) std::cout << #x << ": " << x << std::endl
struct segtree{
    ull hashs[N * 4][2];
     
    void maintain(int rt,int l,int r) {
        int mid = (l + r) / 2;
        hashs[rt][0] = hashs[rt*2][0] + hashs[rt*2+1][0] * pow[mid - l + 1];
        hashs[rt][1] = hashs[rt*2+1][1] + hashs[rt*2][1] * pow[r - mid];
 
    }
 
    void change(int rt,int l,int r,int pos,int val) {
        if(l == r) {
            hashs[rt][0] = hashs[rt][1] = val;
            return ;
        }   
        int mid = (l + r) / 2;
        if(pos > mid) 
            change(rt*2+1,mid+1,r,pos,val);
        else
            change(rt*2,l,mid,pos,val);
 
        maintain(rt,l,r);
    }
 
    work query(int rt,int l,int r,int ql,int qr) {
        if(r < ql || qr < l) {
            return (work){0,0,0};
        } 
        else if(ql <= l && r <= qr) {
            return (work){hashs[rt][0],hashs[rt][1],r - l + 1};
        }
        int mid = (l + r) / 2;
        work wa = query(rt*2,l,mid,ql,qr);
        work wb = query(rt*2+1,mid+1,r,ql,qr);
        return (work){wa.hash0 + wb.hash0 * pow[wa.len],
                        wb.hash1 + wa.hash1 * pow[wb.len],
                            wa.len + wb.len};
    }
 
}seg;
 
int main()
{
    pow[0] = 1;
    for(int i = 1;i < N;++i) pow[i] = 3 * pow[i-1];
    std::ios::sync_with_stdio(false);
    std::cin >> T;
    while(T--) {
        int f = 0;
        memset(&seg,0,sizeof(seg));
        std::cin >> n;
        for(int i = 1;i <= n;++i) {
            std::cin >> a[i];
            seg.change(1,1,n,a[i],1);
            if(a[i] == 1 || a[i] == n) continue;
            int len = std::min(a[i]-1,n - a[i]);
            work wa = seg.query(1,1,n,a[i]-len,a[i]-1);
            work wb = seg.query(1,1,n,a[i]+1,a[i]+len);
            if(wa.hash0 != wb.hash1) {
                f = 1;
            }
        }
        if(!f) 
            std::cout << "N" << std::endl;
        else
            std::cout << "Y" << std::endl;
    }
 
    return 0;
}