3223: Tyvj 1729 文艺平衡树

Description

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：翻转一个区间，例如原有序序列是5 4 3 2 1，翻转区间是[2,4]的话，结果是5 2 3 4 1

Input

第一行为n,m n表示初始序列有n个数，这个序列依次是(1,2……n-1,n) m表示翻转操作次数
接下来m行每行两个数[l,r] 数据保证 1<=l<=r<=n

Output

输出一行n个数字，表示原始序列经过m次变换后的结果

Sample Input

5 3

1 3

1 3

1 4

Sample Output

4 3 2 1 5

HINT

N,M<=100000

好久没写，水一发splay。。。。。。

const
    maxn=100100;
type
    node=record
      son:array[0..1]of longint;
      a,fa,size:longint;
      sw:boolean;
    end;
var
    f:array[0..maxn]of node;
    n,m,root:longint;

function build(l,r,ff:longint):longint;
var
    mid:longint;
begin
    mid:=(l+r)>>1;
    f[mid].fa:=ff;
    f[mid].size:=r-l+1;
    if mid>l then f[mid].son[0]:=build(l,mid-1,mid);
    if (mid>1) and (mid<n+2) then f[mid].a:=mid-1;
    if mid<r then f[mid].son[1]:=build(mid+1,r,mid);
    exit(mid);
end;

procedure swap(var x,y:longint);
var
    t:longint;
begin
    t:=x;x:=y;y:=t;
end;

procedure new(x:longint);
begin
    with f[x] do
      begin
        size:=f[son[0]].size+f[son[1]].size+1;
        if sw then
        begin
          swap(son[0],son[1]);
          f[son[0]].sw:=not f[son[0]].sw;
          f[son[1]].sw:=not f[son[1]].sw;
          sw:=not sw;
        end;
      end;
end;

function wh(x:longint):longint;
begin
    if f[f[x].fa].son[0]=x then exit(0);
    exit(1);
end;

procedure rotate(x,w:longint);
var
    y:longint;
begin
    y:=f[x].fa;
    f[y].son[w]:=f[x].son[w xor 1];
    if f[x].son[w xor 1]<>0 then f[f[x].son[w xor 1]].fa:=y;
    f[x].son[w xor 1]:=y;
    if root=y then root:=x
    else f[f[y].fa].son[wh(y)]:=x;
    f[x].fa:=f[y].fa;
    f[y].fa:=x;
    new(y);
end;

procedure splay(x,z:longint);
var
    y:longint;
begin
    while f[x].fa<>z do
      begin
        y:=f[x].fa;
        if f[y].fa<>z then
          begin
            if wh(x)=wh(y) then rotate(y,wh(y))
            else rotate(x,wh(x));
          end;
        rotate(x,wh(x));
      end;
    new(x);
end;

function find(k:longint):longint;
begin
    find:=root;
    while true do
      begin
        new(find);
        if k=f[f[find].son[0]].size+1 then exit(find);
        if k<=f[f[find].son[0]].size then find:=f[find].son[0]
        else
          begin
            dec(k,f[f[find].son[0]].size+1);
            find:=f[find].son[1];
          end;
      end;
end;

var
    aa:array[0..maxn]of longint;
    tot:longint;

procedure dfs(x:longint);
begin
    new(x);
    with f[x] do
      begin
        if son[0]<>0 then dfs(son[0]);
        inc(tot);
        aa[tot]:=a;
        if son[1]<>0 then dfs(son[1]);
      end;
end;

procedure main;
var
    i,l,r:longint;
begin
    read(n,m);
    root:=build(1,n+2,0);
    for i:=1 to m do
      begin
        read(l,r);
        splay(find(l),0);
        splay(find(r+2),root);
        f[f[f[root].son[1]].son[0]].sw:=not f[f[f[root].son[1]].son[0]].sw;
      end;
    splay(find(1),0);
    splay(find(n+2),root);
    dfs(f[f[root].son[1]].son[0]);
    for i:=1 to n-1 do
      write(aa[i],' ');
    write(aa[n]);
end;

begin
    main;
end.