51Nod 1463 离线+线段树

题目链接

---

题意：
给定：
两个长度为n的数列A 、B
一个有m个元素的集合K
询问Q次
每次询问[l,r]，输出区间内满足|Bi-Bj|∈K 的最大Ai+Aj

数据约定：
n,Q<=100000
m <= 10
0<=A[i]<=1000000000
1<=B[i]<=n
1<=K[i]<=n
保证B[i]互不相等

---

思路：
考虑利用m很小的性质作为突破口：

对于每一个$B_i$，我们都可以直接枚举出一个合法的$B_j$满足：
$|Bi-Bj|\in K$且$Ai+Aj$最大。

但此时出现了一个矛盾点：
对于每次枚举$B_i$和$B_j$以后，得到的$A_i+A_j$，我们应该如何维护，放在下标为$i$的点还是放在下标为$j$的点呢？

对于这种矛盾，一个有效地处理方式就是离线处理询问。

我们将询问离线以后，按右端点进行排序。当我们询问区间$[l_i,r_i]$时，我们只枚举$[1,r_i]$区间的点作为$B_i$和$B_j$ $(i<j)$。
随后将所得的$A_i+A_j$的值放在下标为$i$的位置，使用数据结构进行维护。

这样每次查询的值就是当前区间的合法最大值了。

此题得解。

---

代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;
#define lson rt<<1
#define rson rt<<1|1

const int A = 2e5 + 10;
const int B = 100 + 10;

class Qra{
public:
    int l,r;
    int id;

    bool operator<(const Qra& rhs) const{
        if(r == rhs.r) return l < rhs.l;
        return r < rhs.r;
    }
}Q[A<<1];

class Seg_Tree{
public:
    int l,r;
    int Mx;
}Tree[A<<2];

int a[A],b[A],k[B],pos[A],Ans[A],Out[A];
int n,q,m;

void push_up(int rt){
    Tree[rt].Mx = max(Tree[lson].Mx,Tree[rson].Mx);
}

void Build_Tree(int rt,int l,int r){
    Tree[rt].l = l,Tree[rt].r = r;
    Tree[rt].Mx = 0;
    if(l == r) return;

    int mid = (l+r)>>1;
    Build_Tree(lson,l,mid);
    Build_Tree(rson,mid+1,r);
    push_up(rt);
}

void Update_Tree(int rt,int pos,int val){
    int l = Tree[rt].l,r = Tree[rt].r;
    if(l == r){
        Tree[rt].Mx = val;
        return;
    }
    int mid = (l+r)>>1;
    if(pos <= mid) Update_Tree(lson,pos,val);
    else           Update_Tree(rson,pos,val);
    push_up(rt);
}

int Query(int rt,int st,int ed){
    int l = Tree[rt].l,r = Tree[rt].r;
    if(st<=l && r<=ed){
        return Tree[rt].Mx;
    }

    int res = 0;
    int mid = (l+r)>>1;
    if(st<=mid) res = max(res,Query(lson,st,ed));
    if(ed> mid) res = max(res,Query(rson,st,ed));

    return res;
}

void check(int y,int id){
    if(y>=1 && y<=n && pos[y]<=id){
        if(a[id]+a[pos[y]] > Ans[pos[y]]){
            Update_Tree(1,pos[y],a[id]+a[pos[y]]);
            Ans[pos[y]] = a[id]+a[pos[y]];
        }
    }
}

void update(int id){
    int y = 0;
    for(int i=1 ;i<=m ;i++){
        y = b[id] - k[i];
        check(y,id);
        y = b[id] + k[i];
        check(y,id);
    }
}

int main(){
    scanf("%d%d%d",&n,&q,&m);

    for(int i=1 ;i<=n ;i++) scanf("%d",&a[i]);
    for(int i=1 ;i<=n ;i++) scanf("%d",&b[i]);
    for(int i=1 ;i<=m ;i++) scanf("%d",&k[i]);

    for(int i=1 ;i<=q ;i++){
        scanf("%d%d",&Q[i].l,&Q[i].r);
        Q[i].id = i;
    }
    sort(Q+1,Q+1+q);

    for(int i=1 ;i<=n ;i++){
        pos[b[i]] = i;
    }

    memset(Ans,0,sizeof(Ans));
    Build_Tree(1,1,n);
    int ed = 1;
    for(int i=1 ;i<=q ;i++){
        while(ed<=n && ed<=Q[i].r) update(ed++);
        Out[Q[i].id] = Query(1,Q[i].l,Q[i].r);
    }
    for(int i=1 ;i<=q ;i++){
        printf("%d\n",Out[i]);
    }
    return 0;
}