[BZOJ 3938] Robot

最新推荐文章于 2021-05-18 20:23:44 发布

原创最新推荐文章于 2021-05-18 20:23:44 发布 · 281 阅读

0 ·

CC 4.0 BY-SA版权

题目分析同时被 3 个专栏收录

671 篇文章

订阅专栏

线段树

59 篇文章

订阅专栏

李超线段树

3 篇文章

订阅专栏

本文介绍了一道关于机器人移动路径求解的问题，利用超哥线段树进行高效求解。通过离散化时间轴并维护每个机器人不同时段的速度变化，实现对最远距离的快速查询。

题目描述：

emmm.
又是个语死早系列.
我们有 N 个机器人
每个机器人有个初始参量 X
表示机器人初始位置
初始速度为 0
有 M 个询问
首先给出一个时间参量 T
操作1 ：在 T 时间更改机器人 W ，W机器人速度变为 K 表示单位时间移动的距离
操作2 ：询问 T 时间走的最远的机器人距离原点的距离

题目分析：

很明显是一道超哥线段树的题目
将时间轴看做X轴那么每个机器人的行走即为一个一次函数
但与之前的又有些不同
由于每个机器人的速度可以更改所以其实每个机器人的行走函数是由很多函数组成的分段函数
而且机器人可以为速度可以为负数那么我们就不能仅仅维护最大值啦
我分了两棵线段树分别维护一颗线段树维护会导致过度的下放标记，T成SB
当然，我们也不可以直接对时间进行维护
时间最大到了 $10^9$ 而 Q 仅有 $10^5$ 要离散化一下

离散化时间,机器人是在接受到命令的时间才更改速度,对于之前的地方无影响,
导致一个机器人的在每个时间的函数曲线是一条条斜率不同的线段，最后为一条射线，注意分别维护
保证了时间递增！

所以本题维护的是折线版的超哥！

细节是真的多！
另外一题，无脑全部long long T 成了 SB
慢慢改才A（大概是我写的太丑

题目链接：

BZOJ 3938

Ac 代码：

/*
  离散化时间,机器人是在接受到命令的时间才更改速度,对于之前的地方无影响,
  导致一个机器人的在每个时间的函数曲线是一条条斜率不同的线段，注意分别维护
  保证了时间递增 
*/
#include <cstdio>
#include <iostream>
#include <algorithm>
#define ll long long
#define il inline 
const int maxm=600005; 
struct node{
    int opt,id;
    ll tim,k;
};
node q[maxm];
struct tree{
    ll k,b;
    int flag;
};
tree st[2][maxm<<2];
int last[maxm];
int tot,cnt,n,m;
ll ans1,ans2,nowb[maxm],nowk[maxm],tim[maxm];
il ll read1()
{
    ll x=0,w=1;char ch=0;
    while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*w;
}
il int read2()
{
    int x=0,w=1;char ch=0;
    while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*w;
}
il int gettime(ll x)
{
    return std::lower_bound(tim+1,tim+cnt+1,x)-tim;
}
double getx(ll k1,ll b1,ll k2,ll b2)
{
    return (b1-b2)/(1.0*(k2-k1));
}
void ins1(int o,int l,int r,int ql,int qr,ll b,ll k)
{
    int mid=(l+r)>>1;
    if (ql<=l&&r<=qr)
    {
        if (!st[0][o].flag)
        {
            st[0][o].k=k,st[0][o].b=b,st[0][o].flag=1; 
            return; 
        }
        ll tb=st[0][o].b,tk=st[0][o].k;
        ll y1=b+k*tim[l],y2=tb+tk*tim[l];
        ll y3=b+k*tim[r],y4=tb+tk*tim[r];
        if (y1<=y2&&y3<=y4) return;
        if (y1>=y2&&y3>=y4)
        {
            st[0][o].b=b,st[0][o].k=k;
            return;
        } 
        double xx=getx(k,b,tk,tb);
        if (y1>=y2)
        {
            if (xx<=tim[mid]) ins1((o<<1),l,mid,ql,qr,b,k);
            else ins1((o<<1)|1,mid+1,r,ql,qr,tb,tk),st[0][o].b=b,st[0][o].k=k;
        }
        else
        {
            if (xx>tim[mid]) ins1((o<<1)|1,mid+1,r,ql,qr,b,k);
            else ins1((o<<1),l,mid,ql,qr,tb,tk),st[0][o].b=b,st[0][o].k=k;
        }
        return;
    }
    if (ql<=mid) ins1((o<<1),l,mid,ql,qr,b,k);
    if (qr>mid) ins1((o<<1)|1,mid+1,r,ql,qr,b,k);
}
void ins2(int o,int l,int r,int ql,int qr,ll b,ll k)
{
    int mid=(l+r)>>1;
    if (ql<=l&&r<=qr)
    {
        if (!st[1][o].flag)
        {
            st[1][o].k=k,st[1][o].b=b,st[1][o].flag=1; 
            return; 
        }
        ll tb=st[1][o].b,tk=st[1][o].k;
        ll y1=b+k*tim[l],y2=tb+tk*tim[l];
        ll y3=b+k*tim[r],y4=tb+tk*tim[r];
        if (y1>=y2&&y3>=y4) return;
        if (y1<=y2&&y3<=y4)
        {
            st[1][o].b=b,st[1][o].k=k;
            return;
        } 
        double xx=getx(k,b,tk,tb);
        if (y1<=y2)
        {
            if (xx<=tim[mid]) ins2((o<<1),l,mid,ql,qr,b,k);
            else ins2((o<<1)|1,mid+1,r,ql,qr,tb,tk),st[1][o].b=b,st[1][o].k=k;
        }
        else
        {
            if (xx>tim[mid]) ins2((o<<1)|1,mid+1,r,ql,qr,b,k);
            else ins2((o<<1),l,mid,ql,qr,tb,tk),st[1][o].b=b,st[1][o].k=k;
        }
        return;
    }
    if (ql<=mid) ins2((o<<1),l,mid,ql,qr,b,k);
    if (qr>mid) ins2((o<<1)|1,mid+1,r,ql,qr,b,k);
}
void askmax(int o,int l,int r,int ind)
{
    if(st[0][o].flag) ans1=std::max(ans1,st[0][o].b+st[0][o].k*tim[ind]);
    if(l==r) return;
    int mid=(l+r)>>1;
    if(ind<=mid) askmax((o<<1),l,mid,ind);
    else askmax((o<<1)|1,mid+1,r,ind);
}
void askmin(int o,int l,int r,int ind)
{
    if(st[1][o].flag) ans2=std::min(ans2,st[1][o].b+st[1][o].k*tim[ind]);
    if(l==r) return;
    int mid=(l+r)>>1;
    if(ind<=mid) askmin((o<<1),l,mid,ind);
    else askmin((o<<1)|1,mid+1,r,ind);
}
int main()
{
   //freopen("test.in","r",stdin);
   //freopen("x1.out","w",stdout);
   n=read2(),m=read2();
   char s[10];
   for(int i=1;i<=n;i++) nowb[i]=read1(),nowk[i]=0,last[i]=0;
   for(int i=1;i<=m;i++)
   {
      q[i].tim=tim[i]=read2();
      scanf("%s",s);
      if(s[0]=='c') q[i].opt=1,q[i].id=read1(),q[i].k=read2();
      else q[i].opt=0;
   } 
   tim[tot=m+1]=0;
   std::sort(tim+1,tim+tot+1);
   cnt=std::unique(tim+1,tim+tot+1)-tim-1;
   for(int i=1;i<=m;i++)
   if(q[i].opt)
   {
      int x=q[i].id;
      int pre=gettime(last[x]);
      int now=gettime(q[i].tim);
      ins1(1,1,cnt,pre,now,nowb[x],nowk[x]);
      ins2(1,1,cnt,pre,now,nowb[x],nowk[x]);
      nowb[x]=nowb[x]+q[i].tim*(nowk[x]-q[i].k);//得出新的线段的截距 
      nowk[x]=q[i].k;
      last[x]=q[i].tim;
   }
   for(int i=1;i<=n;i++)//最终插入一条从lasttime->inf的射线
   {
       int pre=gettime(last[i]);
       ins1(1,1,cnt,pre,cnt,nowb[i],nowk[i]);
       ins2(1,1,cnt,pre,cnt,nowb[i],nowk[i]);
   } 
   //printf("Yes\n");
   for(int i=1;i<=m;i++)
   if(!q[i].opt)
   {
       ans1=ans2=0;
       int askt=gettime(q[i].tim);
       askmax(1,1,cnt,askt),askmin(1,1,cnt,askt);
       printf("%lld\n",std::max(ans1,-ans2));
   }
   return 0;
}