[最短路 Bfs 二维线段树] JOI Open Contest 2017 Golf

题目大意：给出平面上n个不相交的矩形障碍，以及起点和终点，要求从起点走到终点的折线段段数最少
VIEW PROBLEM - GOLF (JOI17_GOLF)

首先最优解肯定可以只在矩形边所在的直线以及过起点终点平行坐标轴的直线上移动
先预处理出矩形边界能够左右上下延伸的最远距离，转化成一些线段，可以扫描线加线段树
然后就直接bfs，关键操作是找出所有跟当前线段相交的且没被走过的线段，可以把线段放到二维线段树上边扩展边删去

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cassert>
using namespace std;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=400005;
const int M=50000005;

struct SEG{
  int T[N<<2],F[N<<2];
  inline void build(int x,int l,int r,int t){
    F[x]=0;
    if (l==r) return void(T[x]=t);
    int mid=(l+r)>>1; build(x<<1,l,mid,t); build(x<<1|1,mid+1,r,t);
    T[x]=max(T[x<<1],T[x<<1|1]);
  }
  inline void modify(int x,int l,int r,int ql,int qr,int t){
    if (ql<=l && r<=qr){
      T[x]=F[x]=t; return;
    }
    if (F[x]) T[x<<1]=F[x<<1]=T[x<<1|1]=F[x<<1|1]=F[x],F[x]=0;
    int mid=(l+r)>>1;
    if (ql<=mid) modify(x<<1,l,mid,ql,qr,t);
    if (qr>mid) modify(x<<1|1,mid+1,r,ql,qr,t);
    T[x]=max(T[x<<1],T[x<<1|1]);
  }
  inline int query(int x,int l,int r,int t){
    if (l==r) return T[x];
    if (F[x]) T[x<<1]=F[x<<1]=T[x<<1|1]=F[x<<1|1]=F[x],F[x]=0;
    int mid=(l+r)>>1;
    if (t<=mid) return query(x<<1,l,mid,t);
    else return query(x<<1|1,mid+1,r,t);
  }
}Seg;

int Icnt;

int tmp[N],pnt;

struct TTT{
  int rt[N<<2],ncnt;
  int ls[M],rs[M],T[M];
  inline void add(int &x,int l,int r,int t,int idx){
    if (!x) x=++ncnt;
    if (l==r){
      assert((idx && !T[x]) || (T[x] && !idx));
      return void(T[x]=idx);
    }
    int mid=(l+r)>>1;
    if (t<=mid) add(ls[x],l,mid,t,idx);
    else add(rs[x],mid+1,r,t,idx);
    T[x]=(bool)T[ls[x]]||(bool)T[rs[x]];
  }
  inline void query(int x,int l,int r,int ql,int qr){
    if (!T[x]) return;
    if (l==r) return void(tmp[++pnt]=T[x]);
    int mid=(l+r)>>1;
    if (ql<=mid)
      query(ls[x],l,mid,ql,qr);
    if (qr>mid)
      query(rs[x],mid+1,r,ql,qr);
  }
  inline void Add(int x,int l,int r,int ql,int qr,int z,int idx){
    if (ql<=l && r<=qr){
      add(rt[x],1,Icnt,z,idx); return;
    }
    int mid=(l+r)>>1;
    if (ql<=mid) Add(x<<1,l,mid,ql,qr,z,idx);
    if (qr>mid) Add(x<<1|1,mid+1,r,ql,qr,z,idx);
  }
  inline void Query(int x,int l,int r,int t,int ql,int qr){
    query(rt[x],1,Icnt,ql,qr);
    if (l==r) return;
    int mid=(l+r)>>1;
    if (t<=mid) Query(x<<1,l,mid,t,ql,qr);
    else Query(x<<1|1,mid+1,r,t,ql,qr);
  }
}TT[2];

struct abcd{
  int f,x,y1,y2;
  abcd(int f=0,int x=0,int y1=0,int y2=0):f(f),x(x),y1(y1),y2(y2){ }
  bool operator < (const abcd & B) const{
    return x==B.x?(y1==B.y1?(y2==B.y2?f<B.f:y2<B.y2):y1<B.y1):x<B.x;
  }
  bool operator == (const abcd &B) const{
    return x==B.x && y1==B.y1 && y2==B.y2 && f==B.f;
  }
}L[N<<2];
int Tot;

int X1,Y1,X2,Y2;
int n,A[N],B[N],C[N],D[N];
int sx[N],icntx,sy[N],icnty;
inline int Bin(int x,int *sx,int icnt){
  return lower_bound(sx+1,sx+icnt+1,x)-sx;
}

struct event{
  int f,x,y1,y2;
  event(){ }
  event(int f,int x,int y1,int y2):f(f),x(x),y1(y1),y2(y2){ }
  bool operator < (const event &B) const{
    return x<B.x;
  }
}ev[N<<2];
int tot;

inline void Pre(int *A,int *B,int *C,int *D,int *L1,int *L2){
  Seg.build(1,1,Icnt,1); tot=0;
  for (int i=1;i<=n;i++){
    ev[++tot]=event(1,B[i],C[i],D[i]);
    ev[++tot]=event(2,A[i],C[i],i);
    ev[++tot]=event(2,A[i],D[i],i+n);
  }
  sort(ev+1,ev+tot+1);
  for (int i=1;i<=tot;i++)
    if (ev[i].f==1){
      if (ev[i].y1+1<=ev[i].y2-1)
    Seg.modify(1,1,Icnt,ev[i].y1+1,ev[i].y2-1,ev[i].x);
    }else{
      int &x=ev[i].y2<=n?L1[ev[i].y2]:L2[ev[i].y2-n];
      x=Seg.query(1,1,Icnt,ev[i].y1);
    }
}

int ul[N],ur[N],dl[N],dr[N];
int lu[N],ld[N],ru[N],rd[N];

int Q[N<<2],l,r;
int dis[N<<2];

int s1,s2;
int t1,t2;

inline void Bfs(){
  for (int i=1;i<=Tot;i++) dis[i]=1<<30;
  l=r=-1;
  for (int i=1;i<=Tot;i++){
    if (L[i]==abcd(0,C[n-1],dl[n-1],dr[n-1])) s1=i;
    if (L[i]==abcd(1,A[n-1],ld[n-1],lu[n-1])) s2=i;
    if (L[i]==abcd(0,C[n],dl[n],dr[n])) t1=i;
    if (L[i]==abcd(1,A[n],ld[n],lu[n])) t2=i;
  }
  Q[++r]=s1,Q[++r]=s2; dis[s1]=dis[s2]=0;
  int v=s1; TT[L[v].f].Add(1,1,Icnt,L[v].y1,L[v].y2,L[v].x,0);
  v=s2; TT[L[v].f].Add(1,1,Icnt,L[v].y1,L[v].y2,L[v].x,0);
  while (l<r){
    int u=Q[++l];
    pnt=0;
    TT[L[u].f^1].Query(1,1,Icnt,L[u].x,L[u].y1,L[u].y2);
    for (int i=1;i<=pnt;i++){
      int v=tmp[i]; Q[++r]=v;
      assert(dis[v]==1<<30);
      dis[v]=dis[u]+1;
      TT[L[v].f].Add(1,1,Icnt,L[v].y1,L[v].y2,L[v].x,0);
    }
  }
}

int main(){
  //freopen("t.in","r",stdin);
  //freopen("t.out","w",stdout);
  read(X1); read(Y1); read(X2); read(Y2); read(n); sx[++icntx]=X1,sx[++icntx]=X2,sy[++icnty]=Y1,sy[++icnty]=Y2;
  for (int i=1;i<=n;i++)
    read(A[i]),read(B[i]),read(C[i]),read(D[i]),sx[++icntx]=A[i],sx[++icntx]=B[i],sy[++icnty]=C[i],sy[++icnty]=D[i];
  ++n; A[n]=B[n]=X1,C[n]=D[n]=Y1; ++n; A[n]=B[n]=X2,C[n]=D[n]=Y2;
  sort(sx+1,sx+icntx+1); icntx=unique(sx+1,sx+icntx+1)-sx-1;
  sort(sy+1,sy+icnty+1); icnty=unique(sy+1,sy+icnty+1)-sy-1;
  for (int i=1;i<=n;i++)
    A[i]=Bin(A[i],sx,icntx),B[i]=Bin(B[i],sx,icntx),C[i]=Bin(C[i],sy,icnty),D[i]=Bin(D[i],sy,icnty);
  Icnt=max(icntx,icnty);

  Pre(A,B,C,D,dl,ul);
  for (int i=1;i<=n;i++) B[i]=icntx-B[i]+1,A[i]=icntx-A[i]+1;
  Pre(B,A,C,D,dr,ur);
  for (int i=1;i<=n;i++)
    B[i]=icntx-B[i]+1,A[i]=icntx-A[i]+1,ur[i]=icntx-ur[i]+1,dr[i]=icntx-dr[i]+1;

  Pre(C,D,A,B,ld,rd);
  for (int i=1;i<=n;i++) C[i]=icnty-C[i]+1,D[i]=icnty-D[i]+1;
  Pre(D,C,A,B,lu,ru);
  for (int i=1;i<=n;i++)
    C[i]=icnty-C[i]+1,D[i]=icnty-D[i]+1,lu[i]=icnty-lu[i]+1,ru[i]=icnty-ru[i]+1;
  for (int i=1;i<=n;i++){
    L[++Tot]=abcd(0,C[i],dl[i],dr[i]);
    L[++Tot]=abcd(0,D[i],ul[i],ur[i]);
    L[++Tot]=abcd(1,A[i],ld[i],lu[i]);
    L[++Tot]=abcd(1,B[i],rd[i],ru[i]);
  }
  sort(L+1,L+Tot+1); Tot=unique(L+1,L+Tot+1)-L-1;
  for (int i=1;i<=Tot;i++)
    TT[L[i].f].Add(1,1,Icnt,L[i].y1,L[i].y2,L[i].x,i);
  Bfs();
  printf("%d\n",min(dis[t1],dis[t2])+1);
  return 0;
}