splay瞎存

#define WMX aiaiaiai~~~
#include <bits/stdc++.h>
#define LL long long 
#define Re register int
#define St short
#define ki cout << endl 
#define fk cout << " ";
#define LD double
#define frein(x) freopen(#x ".in", "r", stdin);
#define freout(x) freopen(#x ".out", "w", stdout);
#define debug cout << " kkkkkkkx " << endl; 
#define fr(i, j, k) for(Re i = j; i <= k; i ++)
#define fp(i, j, k) for(Re i = j; i >= k; i --)


//冗长的缺省源 
using namespace std;




namespace kiritokazuto {
    auto read = []() {
        LL x = 0;
        int f = 1;
        char c;
        while(!isdigit(c = getchar())) {if(c == '-')f = -1;}
        do{x = (x << 1) + (x << 3) + (c ^ 48);}while(isdigit(c = getchar()));
        return x * f ;
    };
    template <typename T> inline void write(T x) {
        if(x < 0)putchar('-'), x = -x;
        if(x > 9)write(x / 10);putchar(x % 10 | '0');
    }
}
using namespace kiritokazuto;
const int maxn = 1e6 + 10;
int tot = 0;//记录节点个数
int rt;//根节点编号 
int son[maxn][2];//0为左儿子,1为右儿子 
int n;
int ans;
//来自冰原骆驼的神奇三招
/*
splay
1.我爹是我爷爷的x儿子，我就是我爷爷的x儿子
2.我是我爹的x儿子，我x ^ 1儿子就是我爹的x儿子
3.我是我爹的x儿子，我爹就是我x ^ 1儿子 
*/ 

struct BST{ 
    int cnt;//节点出现次数 
    int sz;//子树大小 
    int val;//节点权值、 
    int pre;//爹 
    #define pre(x) wmx[x].pre
    #define val(x) wmx[x].val
    #define sz(x) wmx[x].sz
    #define cnt(x) wmx[x].cnt 
    #define lsp(x) son[x][0]
    #define rsp(x) son[x][1]
}wmx[maxn];
//inline太多不太好 
int get(int x) {return x == son[pre(x)][1];}//判断x是哪个儿子，如果返回1为右儿子，返回0为左儿子 
inline void pushup(int x) {
    sz(x) = sz(lsp(x)) + sz(rsp(x)) + cnt(x);
}
void clear(int x) {
    lsp(x) = rsp(x) = pre(x) = val(x) = sz(x) = cnt(x) = 0;
}

inline void rotate(int x) {//旋转 
    int y = pre(x), z = pre(y), sonk = get(x);
    son[y][sonk] = son[x][sonk ^ 1];//因为是get和异或，所以做完之后不论是左旋还是右旋，都上去了，具体操作就是看那三句话 
    if(son[x][sonk ^ 1])pre(son[x][sonk ^ 1]) = y;
    son[x][sonk ^ 1] = y;
    pre(y) = x;
    pre(x) = z;
    if(z)son[z][y == rsp(z)] = x;
    pushup(y);
    pushup(x); 
}
/*
注意，这里的对x左旋或者右旋，顺时针右旋，逆时针左旋 
如果x的父亲是根节点，直接将x左旋或右旋
如果x的父亲不是根节点，且x和父亲的儿子类型相同，首先将其父亲左旋或右旋，然后将x右旋或左旋
如果x的父亲不是根节点，且x和父亲的儿子类型不同，将x左旋再右旋、或者右旋再左旋
*/

inline void splay(int x) {
    for(Re p = pre(x); p = pre(x), p; rotate(x)) 
        if(pre(p)) rotate(get(x) == get(p) ? p : x);
    rt = x;
}
/*
假设插入k 
如果树空了，则直接插入根并退出。
如果当前节点的权值等于k则增加当前节点的大小并更新节点和父亲的信息，将当前节点进行 Splay 操作。
否则按照二叉查找树的性质向下找，找到空节点就插入即可（请不要忘记 Splay 操作）。
*/
inline void insert(int k) {
    if(!rt) {//第一个 
        val(++tot) = k;
        cnt(tot)++;
        rt = tot;
        pushup(rt);
        return;
    }
    int tmp = rt, p = 0;
    while(1) {
        if(val(tmp) == k) {
            cnt(tmp)++;
            pushup(tmp);
            pushup(p);
            splay(tmp);
            break;
        }
        p = tmp;
        tmp = son[tmp][val(tmp) < k];
        if(!tmp) {
            val(++tot) = k;
            cnt(tot)++;
            pre(tot) = p;
            son[p][val(p) < k] = tot;
            pushup(tot);
            pushup(p);
            splay(tot);
            break;
        }
    } 
} 
/*
如果x比当前节点的权值小，向其左子树查找。
如果x比当前节点的权值大，将答案加上左子树（size）和当前节点（cnt）的大小，向其右子树查找。
如果x与当前节点的权值相同，将答案加1并返回。
注意最后需要进行 Splay 操作。
*/
int rk(int k) {
    int res = 0, tmp = rt;
    while(1) {
        if(k < val(tmp)) {
            tmp = lsp(tmp);
        }else {
            res += sz(lsp(tmp));
            if(k == val(tmp)) {
                splay(tmp);
                return res + 1;
            }
            res += cnt(tmp);
            tmp = rsp(tmp);
        }
    }
} 

/*
设k为剩余排名
如果左子树非空且剩余排名k不大于左子树的大小sz ，那么向左子树查找。
否则将k减去左子树的和根的大小。如果此时k的值小于等于0，则返回根节点的权值，否则继续向右子树查找。
*/

int kth(int k) {
    int tmp = rt;
    while(1) {
        if(lsp(tmp) && k <= sz(lsp(tmp))) {
            tmp = lsp(tmp);
        }else {
            k -= cnt(tmp) + sz(lsp(tmp));
            if(k <= 0) {
                splay(tmp);
                return val(tmp);
            }
            tmp = rsp(tmp);
        }
    }
}

/*
前驱定义为小于x的最大的数，那么查询前驱可以转化为：
将x插入（此时x已经在根的位置了）
前驱即为x的左子树中最右边的节点，最后将x删除即可。
*/
int getp() {
    int tmp = lsp(rt);
    if(!tmp)return tmp;
    while(rsp(tmp)) tmp = rsp(tmp);
    splay(tmp);
    return tmp; 
}
/*
后继定义为大于x的最小的数，查询方法和前驱类似
x的右子树中最左边的节点。
*/
int getnxt() {
    int tmp = rsp(rt);
    if(!tmp) return tmp;
    while(lsp(tmp))tmp = lsp(tmp);
    splay(tmp);
    return tmp;
}
/*
合并两棵 Splay 树，设两棵树的根节点分别为x和y，那么我们要求x树中的最大值小于y树中的最小值。合并操作如下：
如果x和y其中之一或两者都为空树，直接返回不为空的那一棵树的根节点或空树。
否则将x树中的最大值splay到根，然后把它的右子树设置为y并更新节点的信息，然后返回这个节点。
*/


/*
删除操作也是一个比较复杂的操作，具体步骤如下：
首先将x旋转到根的位置。
如果cnt[x] > 1(有不止一个x），那么将 cnt[x]减1并退出。
否则,合并它的左右两棵子树即可。
*/
void del(int k) {
    rk(k);
    if(cnt(rt) > 1) {
        cnt(rt)--;
        pushup(rt);
        return;
    }
    if(!lsp(rt) && !rsp(rt)) {
        clear(rt);
        rt = 0;
        return;
    }
    if(!lsp(rt)) {
        int tmp = rt;
        rt = rsp(rt);
        pre(rt) = 0;
        clear(tmp);
        return;
    }
    if(!rsp(rt)) {
        int tmp = rt;
        rt = lsp(rt);
        pre(rt) = 0;
        clear(tmp);
        return;
    }
    int tmp = rt, x = getp();
    pre(rsp(tmp)) = x;
    rsp(x) = rsp(tmp);
    clear(tmp);
    pushup(rt);
    
}

signed main () {
     n = read();
     int tp;
     int opt1, opt2;
     
    fr(i, 1, n){
        tp = read();
        insert(tp);
        if(i == 1){
            ans += tp;
            continue;
        }
        if(cnt(rt) == 1){
            opt1 = getp();
            opt1 = (opt1 == 0) ? -0x7ffffff : val(opt1);
            rk(tp);
            opt2 = getnxt();
            opt2 = (opt2 == 0) ? 0x7ffffff : val(opt2);
            ans += min(tp - opt1, opt2 - tp);  
        //    printf(" kk kk kk k%d \n",ans); 
        }
    }
//    printf("%d",ans); 
}