光荣的梦想

Problem Description

Prince 对他在这片大陆上维护的秩序感到满意，于是决定启程离开艾泽拉斯。在他动身之前，Prince决定赋予King_Bette最强大的能量以守护世界、保卫这里的平衡与和谐。在那个时代，平衡是个梦想。因为有很多奇异的物种拥有各种不稳定的能量，平衡瞬间即被打破。KB决定求助于你，帮助他完成这个梦想。
　　一串数列即表示一个世界的状态。
　　平衡是指这串数列以升序排列。而从一串无序序列到有序序列需要通过交换数列中的元素来实现。KB的能量只能交换相邻两个数字。他想知道他最少需要交换几次就能使数列有序。

Input Format

第1行为数列中数的个数n（n <= 100000）

第2行为n个数（绝对值不超过100000）。表示当前数列的状态。

Output Format

输出一个整数，表示最少需要交换几次能达到平衡状态。

Algorithm Design

线段树/排序二叉树/平衡树treap

Problem Analysis

因为有“只能交换相邻两个数字”这个条件，所以交换的总次数是数列中逆序对的个数。证明：在一个数列中，维护一个长度为i的从1到i的单调队列，每次i增长1，推入第i+1个数，为保证单调队列，i要进行当前自身的逆序对个数次交换。以此类推，交换的总次数为数列中逆序对的个数，证毕。

   线段树

求解逆序对的方法很多，可以处理前缀和，每次记录前i个数中每个数的个数，数字x的逆序对个数即为1~x-1的所有数个数之和，记录每个数的个数原本为O（n），可以用线段树优化为O（log2n）。因为极限数据下数字个数与数字大小差不多，所以觉得离散化没有必要，但是离散化可以避免负数的情况，值得优化。（虽然不离散化的也可以处理负数并且过了…）

线段树打完错了很多次，因为100000^2是个大整数却没有意识到..

 排序二叉树

同理啦。。

Source Code

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int n,place[100010],num[100010];
ll ans;

pair <int,int> sortnum[100010];

struct node
{
    int l,r,add;
    ll s;
#define l(i) seg_tree[i].l
#define r(i) seg_tree[i].r
#define s(i) seg_tree[i].s
#define add(i) seg_tree[i].add
#define lkid sub<<1
#define rkid sub<<1|1
}seg_tree[400040];

void build_tree(int sub,int l,int r)
{
    l(sub)=l;
    r(sub)=r;
    s(sub)=0;
    if(l==r)
        return ;
    int mid=(l+r)>>1;
    build_tree(lkid,l,mid);
    build_tree(rkid,mid+1,r);
    return ;
}

void push_down(int sub)
{
    if(!add(sub))
        return ;
    s(lkid)+=add(sub)*(r(lkid)-l(lkid)+1);
    s(rkid)+=add(sub)*(r(rkid)-l(rkid)+1);
    add(lkid)+=add(sub);
    add(rkid)+=add(sub);
    add(sub)=0;
}

void change(int sub,int l,int r)
{
    if(l(sub)>r||r(sub)<l)
        return ;
    if(l(sub)>=l&&r(sub)<=r)
    {
        s(sub)+=r(sub)-l(sub)+1;
        add(sub)++;
        return ;
    }
    push_down(sub);
    change(lkid,l,r);
    change(rkid,l,r);
    s(sub)=s(lkid)+s(rkid);
    return ;
}

int query(int sub,int tar)
{
    if(l(sub)>tar||r(sub)<tar)
        return 0;
    if(l(sub)==tar&&r(sub)==tar)
        return s(sub);
    push_down(sub);
    return query(lkid,tar)+query(rkid,tar);
}

int main()
{
    freopen("dream.in","r",stdin);
    freopen("dream.out","w",stdout);
    cin>>n;
    build_tree(1,1,n);
    for(int i=1;i<=n;i++)
    {
        cin>>num[i];
        sortnum[i]=make_pair(num[i],i);
    }
    sort(sortnum+1,sortnum+n+1);
    for(int i=1;i<=n;i++)
        place[sortnum[i].second]=i;
    for(int i=1;i<=n;i++)
    {
        change(1,1,place[i]-1);
        ans+=query(1,place[i]);
    }
    cout<<ans<<endl;
    return 0;
}

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int n;
ll ans;

struct node
{
    ll data;
    int l,r,sum;
}tree[100010];

void push_into(int sub)
{
    int cpr=1;
    while(1)
    {
        if(tree[sub].data<tree[cpr].data)
        {
            ans+=tree[cpr].sum;
            if(tree[cpr].l)
                cpr=tree[cpr].l;
            else 
            {
                tree[cpr].l=sub;
                tree[sub].sum=1;
                return;
            }
        }
        else
        {
            tree[cpr].sum++;
            if(tree[cpr].r)
                cpr=tree[cpr].r;
            else 
            {
                tree[cpr].r=sub;
                tree[sub].sum=1;
                return;
            }
        }    
    }
    return;
}

int main()
{
    freopen("dream.in","r",stdin);
    freopen("dream.out","w",stdout);
    cin>>n>>tree[1].data;
    tree[1].sum=1;
    for(int i=2;i<=n;i++)
    {
        cin>>tree[i].data;
        push_into(i);
    }
    cout<<ans<<endl;
    return 0;
}

#include <bits/stdc++.h>

#define MAXN 1000001

int n;
long long ans;

int read(){
    int f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){
        f=(ch=='-')?-1:f;
        ch=getchar();
    }
    int get=0;
    while(ch>='0'&&ch<='9'){
        get=(get<<1)+(get<<3)+ch-'0';
        ch=getchar();
    }
    return get;
}

class treap{
    private:
        int tot;
        class leaf{
            public:
                int size,data,pri,cnt,son[2];
                void init(int x,int y){
                    size=1;
                    data=x;
                    pri=y;
                    cnt=1;
                }
#define size(i) tree[i].size
#define data(i) tree[i].data
#define pri(i) tree[i].pri
#define cnt(i) tree[i].cnt
#define son(i,j) tree[i].son[j]
        }tree[MAXN];
        void update(int i){
            size(i)=size(son(i,0))+size(son(i,1))+cnt(i);
        }
        void rotate(int &r,int f){
            int l=son(r,f);
            son(r,f)=son(l,!f);
            son(l,!f)=r;
            update(r);
            update(r=l);
        }
    public:
        int root;
        void insert(int &i,int data,long long &cnt){
            if(!i){
                tree[i=++tot].init(data,rand());
                return;
            }
            if(data==data(i)){
                cnt(i)++;
                cnt+=size(son(i,1));
            }
            else{
                int f=data>data(i);
                cnt+=(!f)?size(i)-size(son(i,0)):0;
                insert(son(i,f),data,cnt);
                if(pri(son(i,f))>pri(i))
                    rotate(i,f);
            }
            update(i);
        }
}tree;

int main(){
    freopen("dream.in","r",stdin);
    freopen("dream.out","w",stdout);
    srand(time(NULL));
    n=read();
    while(n--){
        int num=read();
        tree.insert(tree.root,num,ans);
    }
    std::cout<<ans<<std::endl;
    return 0;
}

over~