POJ 2528

POJ 2528

题目大意：同上，只是x，y属于[1,10000000]，最后询问能在这个[1,10000000]区间上能看见多少种颜色。

解：线段树+离散化，把可能的端点值存起来，排序，在对应回去，然后线段数即可，1re是因为tree数组的大小没有考虑到端点数*2而再*2,2tle是因为find写错了，然后3wa是因为离散化？这里是个重点，因为离散化之后比如[1,2][4,5]，虽然中间有区间[3,3]但是如果按上文离散化则会出问题，奇怪的是我的处理+上这个判断，如果两个数之间有其他数，则再离散化多这个中间数，但是wa了，有空回来复习的时候检查一下，把特殊处理删除反而ac了，第二天过来看，看了别人的帖子，说把每个端点+1，-1也离散化即可，试了试ac了。

//poj 2528
const
        maxn=11111;
        inf='1.txt';
type
        data=record
          mid, l, r, st, ed, c: longint;
        end;
        dota=record
          l, r: longint;
        end;
var
        tmp, void: array[0..maxn*6]of longint;
        a: array[0..maxn]of dota;
        tree: array[0..maxn*4*6{!!!!!}]of data;
        col: array[0..maxn]of boolean;
        tot, len, ans, test, n: longint;
procedure _qsort(b, e: longint);
var
        i, j, k, x: longint;
begin
  i := b; j := e;
  x := tmp[(i+j)>>1];
  repeat
    while (tmp[i]<x) do inc(i);
    while (tmp[j]>x) do dec(j);
    if i<=j then begin
      k := tmp[i]; tmp[i] := tmp[j]; tmp[j] := k;
      inc(i); dec(j);
    end;
  until i>j;
  if j>b then _qsort(b, j);
  if i<e then _qsort(i, e);
end;

function _find(x: longint): longint;
var
        left, right, mid: longint;
begin
  left := 1; right := tot;
  while left<=right do begin
    mid := (left+right)>>1;
    if void[mid]=x then break;
    if void[mid]>x then right := mid-1;
    if void[mid]<x then left := mid+1;
  end;
  exit(mid);
end;

procedure _together;
var
        i, j: longint;
begin
  _qsort(1, len);
  tot := 0; i := 1;
  while i<=len do begin
    inc(tot); void[tot] := tmp[i];
    inc(i);
    while (tmp[i]=tmp[i-1])and(i<=len) do inc(i);
    {if (i<=len)and(tmp[i]-tmp[i-1]>1) then begin
      inc(tot); void[tot] := tmp[i]-1;
    end; }
  end;
  for i := 1 to n do with a[i] do begin
    l := _find(l);
    r := _find(r);
  end;
end;

procedure _build(const s, e, k: longint);
begin
  with tree[k] do begin
    st := s; ed := e; c := 0;
    mid := (s+e)>>1;
    if s=e then exit;
    l := k << 1; _build(st, mid, l);
    r := l + 1; _build(mid+1, ed, r);
  end;
end;

procedure _init;
var
        i: longint;
begin
  tot := 0; ans := 0;
  readln(n);
  for i := 1 to n do with a[i] do begin
    readln(l, r);
    inc(tot); tmp[tot] := l;
    inc(tot); tmp[tot] := l-1;  {!!!}
    inc(tot); tmp[tot] := l+1;
    inc(tot); tmp[tot] := r;
    inc(tot); tmp[tot] := r-1;
    inc(tot); tmp[tot] := r+1;
  end;
  len := tot;
  _together;
  _build(1, tot, 1);
end;

procedure _cover(const s, e, k, color: longint);
begin
  with tree[k] do begin
    if (s<=st)and(ed<=e) then begin
      c := color; exit;
    end;
    if c>0 then begin
      tree[l].c := c; tree[r].c := c;
      c := 0;
    end;
    if s<=mid then _cover(s, e, l, color);
    if e>mid then _cover(s, e, r, color);
  end;
end;

procedure _count(s, e, k: longint);
begin
  with tree[k] do begin
    if c>0 then begin
      col[c] := true; exit;
    end;
    if st=ed then exit;
    _count(s, mid, l);
    _count(mid+1, e, r);
  end;
end;

procedure _main;
var
        i: longint;
begin
  for i := 1 to n do with a[i] do
    _cover(l, r, 1, i);
  _count(1, tot, 1);
  for i := 1 to n do
    if col[i] then begin
      inc(ans); col[i] := false;
    end;
end;

procedure _print;
begin
  writeln(ans);
end;

var
        i: longint;

begin
  assign(input,inf); reset(input);
  fillchar(col, sizeof(col), 0);
  readln(test);
  for i := 1 to test do begin
    _init;
    _main;
    _print;
  end;
end.