Codeforces Round #424 (Div. 2, rated, based on VK Cup Finals) Problem E (Codeforces 831E) - 线段树 - 树状数组

Vasily has a deck of cards consisting of n cards. There is an integer on each of the cards, this integer is between 1 and 100 000, inclusive. It is possible that some cards have the same integers on them.

Vasily decided to sort the cards. To do this, he repeatedly takes the top card from the deck, and if the number on it equals the minimum number written on the cards in the deck, then he places the card away. Otherwise, he puts it under the deck and takes the next card from the top, and so on. The process ends as soon as there are no cards in the deck. You can assume that Vasily always knows the minimum number written on some card in the remaining deck, but doesn't know where this card (or these cards) is.

You are to determine the total number of times Vasily takes the top card from the deck.

Input
The first line contains single integer n (1 ≤ n ≤ 100 000) — the number of cards in the deck.

The second line contains a sequence of n integers a1, a2, ..., an (1 ≤ ai ≤ 100 000), where ai is the number written on the i-th from top card in the deck.

Output
Print the total number of times Vasily takes the top card from the deck.

Examples

input

4
6 3 1 2

output

7

input

1
1000

output

1

input

7
3 3 3 3 3 3 3

output

7

Note
In the first example Vasily at first looks at the card with number 6 on it, puts it under the deck, then on the card with number 3, puts it under the deck, and then on the card with number 1. He places away the card with 1, because the number written on it is the minimum among the remaining cards. After that the cards from top to bottom are [2, 6, 3]. Then Vasily looks at the top card with number 2 and puts it away. After that the cards from top to bottom are [6, 3]. Then Vasily looks at card 6, puts it under the deck, then at card 3 and puts it away. Then there is only one card with number 6 on it, and Vasily looks at it and puts it away. Thus, in total Vasily looks at 7 cards.

　　题目大意 桌面上有一叠卡牌，每张卡牌上有些数。当拿起一张卡牌时，如果它上面的数是当前剩下的牌中的数(包括拿起的这一张)的最小值(假定这个人知道)，就把它"扔掉"，否则把它塞进这叠卡牌的最下面。问把所有卡牌都拿走花了多少次。

　　我很好奇，是老外的数据结构弱吗，每次数据结构题基本都是E,F题(div 2。div 1我就不知道了)。

　　然后不说多的废话了。树状数组维护卡牌是否被拿走(拿走为0，未拿走为1)，线段树维护区间最小值。

　　因为移动的话很麻烦，但是一轮后顺序又正常了，所以可以一轮一轮地计算。记录fin(已经拿走的牌的数量)和last（上个拿走的卡牌的下标）。

　　->当fin等于n时停止

　　　　->将last设为1

　　　　->找到last右侧的最小值和整叠卡牌的最小值，判断他们是否相等。

　　　　　　*如果相等

　　　　　　　　->返回最小的最小值下标pos，然后树状数组统计last + 1到pos的和(这中间还有多少没拿走)，更新答案。

　　　　　　　　->将树状数组这一位置为0，线段树中这一位改为inf(不方便delete，就这么干)，fin 加 1,将last设为pos。

　　　　　　*如果不相等

　　　　　　　　->统计last + 1到n的和(把这一轮中剩下的牌都拿完)

　　　　　　　　->break

Code

/**
* Codeforces
* Problem#831E
* Accepted
* Time:109ms
* Memory:7584k
*/
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#include <cassert>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const signed long long llf = (signed long long)((1ull << 61) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
char x;
int aFlag = 1;
while(!isdigit((x = getchar())) && x != '-' && x != -1);
if(x == -1) {
ungetc(x, stdin);
return false;
}
if(x == '-'){
x = getchar();
aFlag = -1;
}
for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
ungetc(x, stdin);
u *= aFlag;
return true;
}

#define lowbit(x) (x & (-x))

typedef class IndexedTree {
public:
int *l;
int size;

IndexedTree() {        }
IndexedTree(int size):size(size) {
l = new int[(size + 1)];
memset(l, 0, sizeof(int) * (size + 1));
}

inline void add(int idx, int val) {
for(; idx <= size; idx += lowbit(idx)) {
l[idx] += val;
}
}

inline int getSum(int idx) {
int ret = 0;
for(; idx; idx -= lowbit(idx))
ret += l[idx];
return ret;
}
}IndexedTree;

typedef class SegTreeNode {
public:
int minid;
int val;
SegTreeNode *l, *r;

SegTreeNode() {        }

inline void pushUp() {
if(l->val <= r->val)
minid = l->minid, val = l->val;
else
minid = r->minid, val = r->val;
}
}SegTreeNode;

typedef class SegTree {
public:
SegTreeNode* root;

SegTree() {        }
SegTree(int n, int* lis) {
build(root, 1, n, lis);
}

void build(SegTreeNode* &node, int l, int r, int *lis) {
node = new SegTreeNode();
if(l == r) {
node->minid = l, node->val = lis[l];
return;
}
int mid = (l + r) >> 1;
build(node->l, l, mid, lis);
build(node->r, mid + 1, r, lis);
node->pushUp();
}

void update(SegTreeNode* &node, int l, int r, int idx, int val) {
if(l == idx && r == idx) {
node->val = val;
return;
}
int mid = (l + r) >> 1;
if(idx <= mid)    update(node->l, l, mid, idx, val);
else update(node->r, mid + 1, r, idx, val);
node->pushUp();
}

void query(SegTreeNode*& node, int l, int r, int ql, int qr, int& idx, int& minv) {
if(l == ql && r == qr) {
if(node->val < minv)
idx = node->minid, minv = node->val;
return;
}
int mid = (l + r) >> 1;
if(qr <= mid) query(node->l, l, mid, ql, qr, idx, minv);
else if(ql > mid)    query(node->r, mid + 1, r, ql, qr, idx, minv);
else {
int a = -1, b = inf;
query(node->l, l, mid, ql, mid, a, b);
query(node->r, mid + 1, r, mid + 1, qr, idx, minv);
if(b <= minv) {
minv = b, idx = a;
}
}
}
}SegTree;

int n;
int *a;
IndexedTree st;
SegTree st1;

inline void init() {
readInteger(n);
a = new int[n + 1];
for(int i = 1; i <= n; i++) {
readInteger(a[i]);
}
}

long long res = 0;
inline void solve() {
st = IndexedTree(n);
st1 = SegTree(n, a);
for(int i = 1; i <= n; i++)    st.add(i, 1);

for(int fin = 0; fin < n; ) {
for(int last = 0; fin < n && last < n; ) {
int stand, idx, minv1 = inf, minv2 = inf;
st1.query(st1.root, 1, n, 1, n, stand, minv1);
st1.query(st1.root, 1, n, last + 1, n, idx, minv2);
if(minv1 != minv2) {
res += st.getSum(n) - st.getSum(last);
break;
}
res += st.getSum(idx) - st.getSum(last);
st.add(idx, -1);
st1.update(st1.root, 1, n, idx, inf);
fin++;
last = idx;
}
}
printf(Auto, res);
}

int main() {
init();
solve();
return 0;
}