BZOJ 3533 [Sdoi2014]向量集（线段树套凸包）（含对拍）

最新推荐文章于 2021-01-22 16:24:13 发布

星辰大少主

最新推荐文章于 2021-01-22 16:24:13 发布

阅读量234

点赞数

分类专栏：线段树计算几何凸包三分

本文链接：https://blog.csdn.net/xiaoming_p/article/details/79426952

版权

线段树同时被 3 个专栏收录

4 篇文章 0 订阅

订阅专栏

三分

3 篇文章 0 订阅

订阅专栏

计算几何

2 篇文章 0 订阅

订阅专栏

题目大意

强制在线
操作1：在一个序列后加入一个向量
操作2：给定一个向量a，查找一个区间里面区间与向量a点乘的最大值。
范围是4e5

分析

分析之前必须说两句，妈的学个计算几何打算找个板子弄了个这么恼火的东西，感觉再也忘不了凸包了。。。里面还有三分这种并没有学过的东西（好在不是很难）。

然后码了一下午，在BZOJ上面RE了一晚上，关键是这里的RE是由于强制在线出现错误答案造成的，我去哦。。。。

首先看题目吧，这种就拿着化简式子呗，看看有没有单调性。
直接把向量当成点来看，先研究没有区间的情况。
假设当前需要查询的是(x,y),区间类的某一个元素(ai,bi)
ans=x*ai+y*bi
接下来的处理中，我们大可以把x,y当做定值来看待，真正的参数是ai,bi
bi=-x/y*ai+ans/yi
因此直接把ai看做自变量，bi看做因变量。
借助一点高一学的线性规划的那种思想，ans/y是截距
分类讨论y
当y>0的时候，最大化这个截距,答案在上凸包上
当y<0的时候，最小化这个截距,答案在下凸包上
然后大概就可以悟到这个最优的答案是在凸包上的。
最优点的必要条件是该答案点凸包上相连的两条边的的斜率恰好夹着-x/y,这样的点有两个，但是加上上下凸包的限制就成充要条件了。
实际上没有这么麻烦，在找到了对应的半凸包之后，答案是有单调性的，三分即可。

有区间的情况呢？大概线段树是再适合不过的了。
类似树套树的思想，我们这次套凸包，每一个点下面套一个凸包，该凸包由当前区间里面的点组成。
还有一个问题就是线段树每次暴力重构凸包的话时间复杂度就是O(nlogn)的，显然不科学,根据每次都往最后一个加而且还没有修改这个好性质，我们只有当一个区间所有结点都存在了，我们才构建这个凸包（因为元素没加完的时候我们在查询时不会用到这个区间），那么每个区间只求一次凸包，最终时间复杂度O(nlogn)。
有心的朋友可能会发现我没有计算排序时间复杂度，这是因为我们在构建凸包的时候可以加入分治思想以及归并思想，当我们需要计算一个区间的凸包时，该区间左右子树肯定都构建好了凸包，并且点已经被排序了，我们就可以用归并在O(len)的时间复杂度给点排好序了。

注意

RE的话可能是因为强制在线措施
计算几何还是老老实实把点乘叉乘弄成函数吧，容易搞混

代码（后面有暴力和对拍）

正解

#include<cmath>
#include<queue>
#include<cctype>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef double db;
typedef long long LL;
const int maxn=4e5+1005;
const LL inf=1e17;
struct Point{
    int x,y;
    Point(int x0=0,int y0=0):x(x0),y(y0){   }
    friend bool operator<(Point a,Point b)
    {
        return a.x!=b.x?a.x<b.x:a.y<b.y;
    }
    friend Point operator+(Point a,Point b)
    {
        return Point(a.x+b.x,a.y+b.y);
    }
    friend Point operator-(Point a,Point b)
    {
        return Point(a.x-b.x,a.y-b.y);
    }
    friend LL operator*(Point a,Point b)
    {
        return 1ll*a.x*b.x+1ll*a.y*b.y;
    }
    void ins()
    {
        scanf("%d%d",&x,&y);
    }
}q[maxn],t[maxn],p[20*maxn];//原数组（但是会被排序），临时数组，凸包数组 
LL Cross(Point a,Point b)
{
    return 1ll*a.x*b.y-1ll*a.y*b.x;
}
struct SegmentTree
{
    int rt,np,npp,lc[maxn<<1],rc[maxn<<1],a[maxn<<1],b[maxn<<1],c[maxn<<1];
    void Initial()
    {
        rt=np=npp=0;
        memset(lc,0,sizeof(lc));
        memset(rc,0,sizeof(rc));
    }
    void guibing(int now,int L,int R)
    {
        int m=(L+R)>>1;
        int i=L,j=m+1,cnt=0;
        while(i<=m && j<=R)t[++cnt]=q[i]<q[j]?q[i++]:q[j++];
        while(i<=m)t[++cnt]=q[i++];
        while(j<=R)t[++cnt]=q[j++];
        for(int i=L,j=1;i<=R;i++,j++)q[i]=t[j];
    }
    void pushup(int now,int L,int R)
    {
        int t;
        guibing(now,L,R);
        p[++npp]=q[L];
        t=a[now]=npp;
        for(int i=L+1;i<=R;i++)
        {
            while(npp>t && Cross(p[npp]-p[npp-1],q[i]-p[npp-1])<=0)npp--;
            p[++npp]=q[i];
        }
        t=b[now]=npp;
        for(int i=R-1;i>=L;i--)
        {
            while(npp>t && Cross(p[npp]-p[npp-1],q[i]-p[npp-1])<=0)npp--;
            p[++npp]=q[i];
        }
        c[now]=npp;
    }
    void Build(int &now,int L,int R)
    {
        now=++np;
        if(L==R)return;
        int m=(L+R)>>1;
        Build(lc[now],L,m);
        Build(rc[now],m+1,R);
    }
    void modify(int now,int L,int R,int i)
    {
        if(L==R)
        {
            p[++npp]=q[i],a[now]=b[now]=c[now]=npp;
            return;
        }
        int m=(L+R)>>1;
        if(i<=m)modify(lc[now],L,m,i);
        else modify(rc[now],m+1,R,i);
        if(i==R)
            pushup(now,L,R);
    }
    LL sanfen(int L,int R,Point a)
    {
        while(R-L>2)
        {
            int midl=L+(R-L)/3,midr=R-(R-L)/3;
            if(p[midl]*a>p[midr]*a)R=midr;
            else L=midl;
        }
        LL ret=-inf;
        for(int i=L;i<=R;i++)
            ret=max(ret,p[i]*a);
        return ret;
    }
    LL check(int now,Point v)
    {
        if(v.y>0)return sanfen(b[now],c[now],v);
        else return sanfen(a[now],b[now],v);
    }
    LL query(int now,int L,int R,int i,int j,Point v)
    {
        if(i<=L && R<=j)
            return check(now,v);
        int m=(L+R)>>1;
        LL ret=-inf;
        if(i<=m)ret=max(ret,query(lc[now],L,m,i,j,v));
        if(j>m)ret=max(ret,query(rc[now],m+1,R,i,j,v));
        return ret;
    }
}sgt;
inline int decode (int x , long long lastans) {
     return x ^ (lastans & 0x7fffffff);
}
int n,T;
char s[5],op[5];
LL lastans=0;
void Init()
{
    scanf("%d%s",&n,s);
    sgt.Initial();
    sgt.Build(sgt.rt,1,n);
}
void solve()
{
    int i,j;
    Point a;
    for(int qq=1;qq<=n;qq++)
    {
        scanf("%s",op);a.ins();
        if(s[0]!='E')a.x=decode(a.x,lastans),a.y=decode(a.y,lastans);
        if(op[0]=='A')
        {
            q[++T]=a;
            sgt.modify(sgt.rt,1,n,T);
        }
        else
        {
            scanf("%d%d",&i,&j);
            if(s[0]!='E')i=decode(i,lastans),j=decode(j,lastans);
            lastans=sgt.query(sgt.rt,1,n,i,j,a);
            printf("%lld\n",lastans);
        }
    }
}
int main()
{
    Init();
    solve();
    return 0;
}

暴力

#include<cmath>
#include<queue>
#include<cctype>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef double db;
typedef long long LL;
const int maxn=4e5+1005;
const LL inf=1e17;
struct Point{
    int x,y;
    Point(int x0=0,int y0=0):x(x0),y(y0){   }
    friend bool operator<(Point a,Point b)
    {
        return a.x!=b.x?a.x<b.x:a.y<b.y;
    }
    friend Point operator+(Point a,Point b)
    {
        return Point(a.x+b.x,a.y+b.y);
    }
    friend Point operator-(Point a,Point b)
    {
        return Point(a.x-b.x,a.y-b.y);
    }
    friend LL operator*(Point a,Point b)
    {
        return 1ll*a.x*b.x+1ll*a.y*b.y;
    }
    void ins()
    {
        scanf("%d%d",&x,&y);
    }
    void outs()
    {
        printf("%d %d\n",x,y);
    }
}q[maxn];
inline int decode (int x , long long lastans) {
     return x ^ (lastans & 0x7fffffff);
}
int n,T;
char s[5],op[5];
LL lastans=0;
void Init()
{
    scanf("%d%s",&n,s);
}
void solve()
{
    int i,j;
    Point a;
    for(int qq=1;qq<=n;qq++)
    {
        scanf("%s",op);a.ins();
        if(s[0]!='E')a.x=decode(a.x,lastans),a.y=decode(a.y,lastans);
        if(op[0]=='A')
        {
            q[++T]=a;
        }
        else
        {
            scanf("%d%d",&i,&j);
            LL ans=-inf;
            for(int k=i;k<=j;k++)ans=max(ans,a*q[k]);
            printf("%lld\n",ans);
        }
    }
}
int main()
{
    freopen("in.txt","r",stdin);
    freopen("out1.txt","w",stdout);
    Init();
    solve();
    return 0;
}

数据生成

说明：这里我采取先生成加入，后生成输出的不强制在线算法。前者是因为一般来说没什么影响，并且容易调试，后者是因为比较简单。使用者可以自行调整参数。

#include<bits/stdc++.h>
using namespace std;
const int maxn=4e5+1005;
int random(int a)
{
    return (rand()*rand()+rand())%a+1;
}
void outs()
{
    cout<<random(10)<<" "<<random(10)<<" ";
}
int main()
{
    freopen("in.txt","w",stdout);
    int t=0;
    srand(time(NULL));
    int n=2000;
    cout<<n<<" "<<'E'<<endl;
    for(int i=1;i<=n;i++)
    {
        if(i<=1000)
        {
            t++;
            cout<<'A'<<" ";
            outs();
            cout<<endl;
        }
        else
        {
            cout<<'Q'<<" ";
            outs();
            int x=random(t),y=random(t);
            if(x>y)swap(x,y);
            cout<<x<<" "<<y<<endl;
        }
    }
    return 0;
}

对拍

#include<bits/stdc++.h>
using namespace std;
int main()
{
    for(int i=1;i<=100;i++)
    {
        printf("Case: %d\n",i);
        system("数据生成.exe");
        system("暴力.exe");
        system("3533[Sdoi2014]向量集.exe");
        int e=system("fc /N out.txt out1.txt");
        if(e)
        {
            break;
        }
    }
    return 0;
}