bzoj 1588 裸平衡树

//By BLADEVIL
#include <cstdio>
#include <set>
#define inf 1<<30
 
using namespace std;
 
int n,ans;
 
int main()
{
    int x;
    set<int>bt;
    bt.insert(inf); bt.insert(-inf);
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
    {
        //printf(" %d\n",ans);
        if (scanf("%d",&x)==EOF) x=0;
        if (i==1) ans=x,bt.insert(x); else
        {
            int a,b;
            a=*bt.upper_bound(x); b=*(--bt.upper_bound(x));
            ans+=(a-x<x-b)?a-x:x-b;
            bt.insert(x);
        }
    }
    printf("%d\n",ans);
    return 0;
}

 

裸平衡树

 

/**************************************************************
    Problem: 1588
    User: BLADEVIL
    Language: Pascal
    Result: Accepted
    Time:440 ms
    Memory:852 kb
****************************************************************/
 
//By BLADEVIL
var
    n                       :longint;
    ans                     :longint;
    size, left, right, key  :array[0..40000] of longint;
    t, tot                  :longint;
    x                       :longint;
    a, b                    :longint;
    i                       :longint;
     
function min(a,b:longint):longint;
begin
    if a>b then min:=b else min:=a;
end;
 
procedure left_rotate(var t:longint);
var
    k                       :longint;
begin
    k:=right[t];
    right[t]:=left[k];
    left[k]:=t;
    size[k]:=size[t];
    size[t]:=size[left[t]]+size[right[t]]+1;
    t:=k;
end;
 
procedure right_rotate(var t:longint);
var
    k                       :longint;
begin
    k:=left[t];
    left[t]:=right[k];
    right[k]:=t;
    size[k]:=size[t];
    size[t]:=size[left[t]]+size[right[t]]+1;
    t:=k;
end;
 
procedure maintain(var t:longint;flag:boolean);
begin
    if not flag then
    begin
        if size[left[left[t]]]>size[right[t]] then
            right_rotate(t) else
        if size[right[left[t]]]>size[right[t]] then
        begin
            left_rotate(left[t]);
            right_rotate(t);
        end else exit;
    end else
    begin
        if size[right[right[t]]]>size[left[t]] then
            left_rotate(t) else
        if size[left[right[t]]]>size[left[t]] then
        begin
            right_rotate(right[t]);
            left_rotate(t);
        end else exit;
    end;
    maintain(left[t],false);
    maintain(right[t],true);
    maintain(t,true);
    maintain(t,false);
end;
     
procedure insert(var t:longint;v:longint);
begin
    if t=0 then
    begin
        inc(tot);
        t:=tot;
        left[t]:=0;
        right[t]:=0;
        size[t]:=1;
        key[t]:=v;
    end else
    begin
        inc(size[t]);
        if v<key[t] then insert(left[t],v) else insert(right[t],v);
        maintain(t,v>=key[t]);
    end;
end;
 
function pred(var t:longint;v:longint):longint;
begin
    if t=0 then exit(-1);
    if key[t]>v then pred:=pred(left[t],v) else
    begin
        pred:=pred(right[t],v);
        if pred=-1 then pred:=key[t];
    end;
end;
 
function succ(var t:longint;v:longint):longint;
begin
    if t=0 then exit(-1);
    if key[t]<v then succ:=succ(right[t],v) else
    begin
        succ:=succ(left[t],v);
        if succ=-1 then succ:=key[t];
    end;
end;
     
begin
    read(n);
    t:=0; tot:=0;
    read(x);
    ans:=x;
    insert(t,x);
    for i:=2 to n do
    begin
        read(x);
        a:=pred(t,x); b:=succ(t,x);
        if a=-1 then inc(ans,b-x) else
        if b=-1 then inc(ans,x-a) else
        ans:=ans+min(abs(a-x),abs(b-x));
        insert(t,x);
    end;
    writeln(ans);
end.