题目大意：

给你一串数字，操作过程如下：不断把队首数字掉到队尾，如果当前队首数为队列中的最小值，那么就删除队首。两种操作都会使操作数加一。问你至少要操作多少次才能将队列删空。

分析：

首先假如没有重复元素，那么，对于每个数x，当x为当前最小数时，将x调换到队首需要的操作次数为“在删除x之前，要删除的那个数（也就是恰好比x小的数）和x之间所有数中，比x大的数的个数”（如果在x的右边可以转圈循环）。那么我就想到了把数组中的数按照从大到小的顺序添加进去，即：把对应位置的加一，每次查询只需要用树状数组就能完成了。

然后就是对于有相同元素，想到离散化，但是让哪个更大是有讲究的：

我们的贪心策略为：“对于若干个x，把他们按照在x-1的左面还是右面分成两部分，右侧部分标号小于左侧部分；然后再对于同侧部分，右侧标号大于左侧标号。”

这样离散化成功之后，按照上述顺序添加的过程中记录每一个x调换到队首所需的操作次数，并累加就可以了。

注：对于可成环的数列，在数列后面再复制一遍，然后对这个新的二倍长度的数列进行操作是一个比较方便的办法。

代码：

#include<bits/stdc++.h>
#define maxn 200050
using namespace std;
struct point
{
    int val;int pos;
    int id;
};
point a[maxn];
int n;
int tree[maxn];
int lowbit(int x)
{
    return x&(-x);
}
void add(int x)
{
    while(x<maxn)
    {
        tree[x]++;
        x+=lowbit(x);
    }
}
int sum(int x)
{
    int s=0;
    while(x>0)
    {
        s+=tree[x];
        x-=lowbit(x);
    }
    return s;
}

bool pos_cmp(point a,point b)
{
    if(a.val==b.val)return a.pos<b.pos;
    return a.val<b.val;
}
bool id_cmp(point a,point b)
{
    return a.id>b.id;
}
void test()
{
    for(int i=1;i<=n;i++)
    {
        printf("val[%d]=%d pos[%d]=%d id[%d]=%d\n",i,a[i].val,i,a[i].pos,i,a[i].id);
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i].val);
        a[i].pos=i;
    }
    sort(a+1,a+n+1,pos_cmp);
    int now_id=1;
    int now_pos=0,now_val,t=0;
    int i=1,star=1;
    while(now_id<=n)
    {
        t=0;
        star=i;now_val=a[i].val;
        //cout<<a[star].pos<<endl;
        while(a[i].pos<now_pos&&a[i].val==now_val)
        {
            i++;
            t++;
        }
        while(a[i].val==now_val)
        {
            a[i].id=now_id;
            i++;
            now_id++;
        }
        //cout<<t<<endl;
        for(int j=0;j<t;j++)
        {
            a[star+j].id=now_id;
            now_id++;
        }
        now_pos=(t==0)?a[i-1].pos:a[star+t-1].pos;
    }
    sort(a+1,a+n+1,id_cmp);
    //test();
    long long int ans=0;
    add(a[1].pos);add(a[1].pos+n);
    for(int i=2;i<=n;i++)
    {
        add(a[i].pos);
        add(a[i].pos+n);
        ans+=(long long int)((a[i].pos>a[i-1].pos)?(sum(a[i-1].pos+n-1)-sum(a[i].pos)):(sum(a[i-1].pos-1)-sum(a[i].pos)));
        //cout<<ans<<endl;

    }
    cout<<ans+n+a[n].pos-1;
}