bzoj2584

这是bzoj上AC的第700题，一定要是一道神题！！！

当初分组赛的时候讲过拖到现在才写……

我们考虑把垂直方向移动和水平方向移动分开来考虑，不合法的轮数取二者最小

假设考虑的是垂直方向移动，障碍其实就是类似与x线段一定在y线段之前移动的意思

不难想到拓扑图，如果我们求出了一个向上移动的拓扑图，

不难发现只向一个方向移动一定有解，那么合法的方案就是拓扑排序

而求不合法的操作呢？我们考虑把从前往后删除线段变成从后往前添加线段，

如果添加了一个向上移动的线段i，这个线段x坐标范围内出现一条拓扑排序在i前面的线段，那么不合法

如果添加向下移动的线段i，这是看x坐标范围内是否有拓扑排序在i后面的线段

这我们是可以通过x坐标离散化+线段树维护区间最大值最小值搞定的

那么问题就是我们怎么构造拓扑图

裸的想法是O(n2)的，肯定不行……

不难想到，如果i阻碍j，i阻碍k，j阻碍k，我们没必要连i-->k的边

但具体怎么做呢？对于平面内的线段，在某一个地方做一条垂直x轴的直线

与这条直线相交的线段（由于端点的相交允许，我们考虑左端点与直线相交，不考虑与右端点直线相交），构成的阻碍关系可以简化表示成a1-->a2-->a3-->……

这样我们可以顺着x轴做扫描线，然后按照右端点查询-删除-左端点加入-查询的顺序做

每次查询我们这个线段所连的边，只要是前驱覆盖和后继被覆盖即可，我们可以用平衡树来维护前驱后继

这样就只要构造4*n条边即可，那么问题也解决了

对于水平方向同样的道理，旋转一下坐标轴即可

写了10kb真是爽！！！

const inf=100000007;
type point=record
       x,y:longint;
     end;
     way=record
       po,next:longint;
     end;
     line=record
       x,op,id:longint;
     end;

var e:array[0..400010] of way;
    tree,tag:array[0..200010*4,0..1] of longint;
    lin:array[0..200010] of line;
    a:array[0..100010,0..1] of point;
    son:array[0..200010,1..2] of longint;
    u,du,p,fa,b,loc,h,wh,w,q:array[0..200010] of longint;
    d:array[0..200010] of longint;
    sum,x,y,m,root,ans,i,t,n,len:longint;

function max(a,b:longint):longint;
  begin
    if a>b then exit(a) else exit(b);
  end;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

procedure swap(var a,b:point);
  var c:point;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

function cmp(a,b:line):boolean;
  begin
    if a.x=b.x then exit(a.op<b.op)  //注意因为是端点触碰允许，所以先做右端点的扫描线
    else exit(a.x<b.x);
  end;

procedure add(x,y:longint);
  begin
    inc(len);
    e[len].po:=y;
    e[len].next:=p[x];
    p[x]:=len;
    inc(du[y]);
  end;

procedure sortu(l,r:longint);
  var i,j,x:longint;
  begin
    i:=l;
    j:=r;
    x:=d[(l+r) shr 1];
    repeat
      while d[i]<x do inc(i);
      while x<d[j] do dec(j);
      if not(i>j) then
      begin
        swap(d[i],d[j]);
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sortu(l,j);
    if i<r then sortu(i,r);
  end;

procedure sortl(l,r:longint);
  var i,j:longint;
      x,y:line;
  begin
    i:=l;
    j:=r;
    x:=lin[(l+r) shr 1];
    repeat
      while cmp(lin[i],x) do inc(i);
      while cmp(x,lin[j]) do dec(j);
      if not(i>j) then
      begin
        y:=lin[i]; lin[i]:=lin[j]; lin[j]:=y;
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sortl(l,j);
    if i<r then sortl(i,r);
  end;

procedure topsort;
  var h,r,i,x,y:longint;
  begin
    h:=1;
    r:=0;
    for i:=1 to n do
      if du[i]=0 then
      begin
        inc(r);
        q[r]:=i;
      end;

    while h<=r do
    begin
      x:=q[h];
      i:=p[x];
      while i<>0 do
      begin
        y:=e[i].po;
        dec(du[y]);
        if du[y]=0 then
        begin
          inc(r);
          q[r]:=y;
        end;
        i:=e[i].next;
      end;
      inc(h);
    end;
  end;

procedure cov(i,z:longint);
  begin
    tree[i,0]:=min(tree[i,0],z);
    tree[i,1]:=max(tree[i,1],z);
    tag[i,0]:=min(tag[i,0],z);
    tag[i,1]:=max(tag[i,1],z);
  end;

procedure push(i:longint);
  begin
    if tag[i,0]<inf then
    begin
      cov(i*2,tag[i,0]);
      cov(i*2+1,tag[i,0]);
      tag[i,0]:=inf;
    end;
    if tag[i,1]>0 then
    begin
      cov(i*2,tag[i,1]);
      cov(i*2+1,tag[i,1]);
      tag[i,1]:=0;
    end;
  end;

procedure build(i,l,r:longint);
  var m:longint;
  begin
    tree[i,0]:=inf;
    tag[i,0]:=inf;
    tree[i,1]:=0;
    tag[i,1]:=0;
    if l<>r then
    begin
      m:=(l+r) shr 1;
      build(i*2,l,m);
      build(i*2+1,m+1,r);
    end;
  end;

procedure ins(i,l,r,z:longint);
  var m:longint;
  begin
    if (x<=l) and (y>=r) then cov(i,z)
    else begin
      m:=(l+r) shr 1;
      push(i);
      if x<=m then ins(i*2,l,m,z);
      if y>m then ins(i*2+1,m+1,r,z);
      tree[i,0]:=min(tree[i*2,0],tree[i*2+1,0]);
      tree[i,1]:=max(tree[i*2,1],tree[i*2+1,1]);
    end;
  end;

function find(l,r,x:longint):longint;
  var m:longint;
  begin
    while l<=r do
    begin
      m:=(l+r) shr 1;
      if d[m]=x then exit(m);
      if d[m]>x then r:=m-1 else l:=m+1;
    end;
  end;

function ask(i,l,r,k:longint):longint;
  var m,s:longint;
  begin
    if (x<=l) and (y>=r) then exit(tree[i,k])
    else begin
      m:=(l+r) shr 1;
      push(i);
      if k=0 then
      begin
        s:=inf;
        if x<=m then s:=min(s,ask(i*2,l,m,k));
        if y>m then s:=min(s,ask(i*2+1,m+1,r,k));
      end
      else begin
        s:=0;
        if x<=m then s:=max(s,ask(i*2,l,m,k));
        if y>m then s:=max(s,ask(i*2+1,m+1,r,k));
      end;
      exit(s);
    end;
  end;

function make(x,y,z:longint):line;
  begin
    make.x:=x;
    make.id:=y;
    make.op:=z;
  end;

procedure unique;
  var i,t:longint;
  begin
    t:=0;
    for i:=1 to n do
    begin
      inc(t); d[t]:=a[i,0].x;
      inc(t); d[t]:=a[i,1].x;
    end;
    sortu(1,t);
    m:=1;
    for i:=2 to t do
      if d[i]<>d[m] then
      begin
        inc(m);
        d[m]:=d[i];
      end;
  end;

function cmp(i,j:longint):boolean;  //判断阻碍关系
  var mid,pa,pb:extended;
  begin
    mid:=(max(a[i,0].x,a[j,0].x)+min(a[i,1].x,a[j,1].x))/2;
    pa:=(mid-a[i,0].x)/(a[i,1].x-a[i,0].x)*(a[i,1].y-a[i,0].y)+a[i,0].y;
    pb:=(mid-a[j,0].x)/(a[j,1].x-a[j,0].x)*(a[j,1].y-a[j,0].y)+a[j,0].y;
    exit(pa<pb);
  end;

procedure rotate(x,w:longint);
  var y:longint;
  begin
    y:=fa[x];
    if fa[y]<>0 then
    begin
      if son[fa[y],1]=y then son[fa[y],1]:=x
      else son[fa[y],2]:=x;
    end
    else root:=x;
    fa[x]:=fa[y];
    son[y,3-w]:=son[x,w];
    if son[x,w]<>0 then fa[son[x,w]]:=y;
    son[x,w]:=y;
    fa[y]:=x;
  end;

procedure up(x:longint);
  var y:longint;
  begin
    y:=fa[x];
    while y>0 do
    begin
      if h[y]>h[x] then
      begin
        if son[y,1]=x then rotate(x,2)
        else rotate(x,1);
        y:=fa[x];
      end
      else break;
    end;
  end;

procedure sift(i:longint);
  var j1,j2:longint;
  begin
    repeat
      j1:=son[i,1]; j2:=son[i,2];
      if (j1=0) and (j2=0) then exit;
      if (j1=0) or ((h[j1]>h[j2]) and (j2<>0)) then rotate(j2,1)
      else if (j2=0) or ((j1<>0) and (h[j1]<h[j2])) then rotate(j1,2);
    until false;
  end;

procedure newnode(x:longint);
  var p:longint;
  begin
    inc(t); inc(sum);
    b[t]:=x; loc[x]:=t;
    h[t]:=trunc(random*inf)+1;
    fa[t]:=0; son[t,1]:=0; son[t,2]:=0;
    if root=0 then
    begin
      root:=t;
      exit;
    end
    else begin
      p:=root;
      repeat
        if cmp(x,b[p]) then
        begin
          if son[p,1]=0 then
          begin
            son[p,1]:=t;
            break;
          end;
          p:=son[p,1];
        end
        else begin
          if son[p,2]=0 then
          begin
            son[p,2]:=t;
            break;
          end;
          p:=son[p,2];
        end;
      until false;
      fa[t]:=p;
      up(t);
    end;
  end;

procedure delete(x:longint);
  begin
    sift(x);
    if fa[x]<>0 then
    begin
      if son[fa[x],1]=x then son[fa[x],1]:=0
      else son[fa[x],2]:=0;
    end;
    fa[x]:=0;
    dec(sum);
    if sum=0 then root:=0;
  end;

function pre(p,x:longint):longint;
  var tm:longint;
  begin
    if p=0 then exit(-1)
    else begin
      if cmp(b[p],x) then
      begin
        tm:=pre(son[p,2],x);
        if tm=-1 then exit(b[p])
        else exit(tm);
      end
      else exit(pre(son[p,1],x));
    end;
  end;

function suffix(p,x:longint):longint;
  var tm:longint;
  begin
    if p=0 then exit(-1)
    else begin
      if cmp(x,b[p]) then
      begin
        tm:=suffix(son[p,1],x);
        if tm=-1 then exit(b[p])
        else exit(tm);
      end
      else exit(suffix(son[p,2],x));
    end;
  end;

procedure work(p1,p2:longint);
  var i,r,z,pr,su,no:longint;
  begin
    len:=0;
    fillchar(p,sizeof(p),0);
    fillchar(du,sizeof(du),0);
    r:=0;
    for i:=1 to n do
    begin
      inc(r); lin[r]:=make(a[i,0].x,i,1);
      inc(r); lin[r]:=make(a[i,1].x,i,0);
    end;
    sortl(1,r);
    i:=1; t:=0; root:=0;
    while i<=r do
    begin
      z:=lin[i].x;
      while (i<=r) and (lin[i].x=z) do
      begin
        if lin[i].op=1 then newnode(lin[i].id);
        no:=lin[i].id;
        pr:=pre(root,no);
        su:=suffix(root,no);
        if (pr<>-1) and (pr<>no) then add(no,pr);
        if (su<>-1) and (su<>no) then add(su,no);
        if lin[i].op=0 then delete(loc[no]);
        inc(i);
      end;
    end;
    topsort;
    for i:=1 to n do
      w[q[i]]:=i;
    unique;
    build(1,1,m);
    for i:=n downto 1 do
    begin
      x:=find(1,m,a[wh[i],0].x);
      y:=find(1,m,a[wh[i],1].x);
      dec(y);
      if (u[i]=p1) or (u[i]=p2) then
      begin
        if (u[i]=1) or (u[i]=2) then no:=0 else no:=1;
        z:=ask(1,1,m,no);
        if (no=1) and (z>w[wh[i]]) or (no=0) and (z<w[wh[i]]) then
          ans:=min(ans,i);
      end;
      ins(1,1,m,w[wh[i]]);
    end;
  end;

begin
  randomize;
  readln(n);
  for i:=1 to n do
  begin
    read(a[i,0].x,a[i,0].y);
    read(a[i,1].x,a[i,1].y);
    if a[i,0].x>a[i,1].x then swap(a[i,0],a[i,1]);
  end;
  for i:=1 to n do
    readln(wh[i],u[i]);
  ans:=n;
  work(1,3);
  for i:=1 to n do
  begin
    swap(a[i,0].x,a[i,0].y);
    swap(a[i,1].x,a[i,1].y);
    if a[i,0].x>a[i,1].x then swap(a[i,0],a[i,1]);
  end;
  work(0,2);
  writeln(ans);
  for i:=1 to n do
    writeln(q[i],' 2');
end.