hdu 4747 线段树

Mex

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)

Total Submission(s): 2482    Accepted Submission(s): 805


Problem Description

Mex is a function on a set of integers, which is universally used for impartial game theorem. For a non-negative integer set S, mex(S) is defined as the least non-negative integer which is not appeared in S. Now our problem is about mex function on a sequence.

Consider a sequence of non-negative integers {ai}, we define mex(L,R) as the least non-negative integer which is not appeared in the continuous subsequence from aL to aR, inclusive. Now we want to calculate the sum of mex(L,R) for all 1 <= L <= R <= n.

 

Input

The input contains at most 20 test cases.

For each test case, the first line contains one integer n, denoting the length of sequence.

The next line contains n non-integers separated by space, denoting the sequence.

(1 <= n <= 200000, 0 <= ai <= 10^9)

The input ends with n = 0.

 

Output

For each test case, output one line containing a integer denoting the answer.

Sample Input
3
0 1 3
5
1 0 2 0 1
0

Sample Output
5
24

/*
hdu 4747 线段树

表示开始毫无头绪，总觉得和线段树扯不上什么关系- - 弱TAT

我们要求的是mex[i,j](i~j中不存在的最小非负整数)的和，观察可以发现对于1~n,
mex[1,i]是递增的,因为你当前mex值可以在后面出现

然后假设去掉a[1],可以发现在a[1]再次出现之前.mex值大于a[1]的都会变成a[1]
1 0 2 0 1 -> 0 2 3 3 3
去掉a[1] -> 1 1 1 3

然后按照这个思路弄即可，先处理出mex[1,i]的情况并插入线段树,然后处理出a[i]下次
出现的位置。 利用线段树可以求出在a[i]再次出现之前比a[i]大的最小位置，把这段
全部置为a[i](毕竟这个序列是递增的),并能快速求出和.

hhh-2016-03-24 18:15:48
*/
#include <algorithm>
#include <cmath>
#include <queue>
#include <iostream>
#include <cstring>
#include <map>
#include <cstdio>
#include <vector>
#include <functional>
#define lson (i<<1)
#define rson ((i<<1)|1)
using namespace std;
typedef long long ll;
const int maxn = 500550;
struct node
{
int l,r;
ll num;
int Max,add;
int mid()
{
return ((l+r)>>1);
};
} tree[maxn<<2];

int a[maxn],nex[maxn],mex[maxn];
map<int,int> mp;

void update_up(int i)
{
tree[i].num = tree[lson].num+tree[rson].num;
tree[i].Max = max(tree[lson].Max,tree[rson].Max);
}

void build(int i,int l,int r)
{
tree[i].l = l,tree[i].r = r;
tree[i].add = 0;
if(l == r)
{
tree[i].num = mex[l];
tree[i].Max = mex[l];
return ;
}
int mid = tree[i].mid();
build(lson,l,mid);
build(rson,mid+1,r);
update_up(i);
}

void update_down(int i)
{
if(tree[i].add)
{
tree[lson].add = 1;
tree[rson].add = 1;
tree[lson].num = (ll)tree[i].Max*(tree[lson].r-tree[lson].l+1);
tree[rson].num = (ll)tree[i].Max*(tree[rson].r-tree[rson].l+1);
tree[lson].Max= tree[i].Max;
tree[rson].Max= tree[i].Max;
tree[i].add = 0;
}
}
void Insert(int i,int l,int r,int val)
{
if(tree[i].l >= l && r >= tree[i].r)
{
tree[i].num = (ll)(tree[i].r-tree[i].l+1)*val;
tree[i].Max = val;
tree[i].add = 1;
return;
}
update_down(i);
int mid = tree[i].mid();
if(l <= mid)
Insert(lson,l,r,val);
if(r > mid)
Insert(rson,l,r,val);
update_up(i);
}
int cur;
void get_k(int i,int k)
{
if(tree[i].l == tree[i].r)
{
cur = tree[i].l;
return ;
}
update_down(i);
//int mid = tree[i].mid();
if(k < tree[lson].Max)
get_k(lson,k);
else
get_k(rson,k);
update_up(i);
}

ll query(int i,int l,int r)
{
if(tree[i].l >= l && r >= tree[i].r)
{
return tree[i].num;
}
update_down(i);
int mid = tree[i].mid();
ll ad = 0;
if(l <= mid)
ad += query(lson,l,r);
if(r > mid)
ad += query(rson,l,r);
update_up(i);
return ad;
}

int main()
{
int n;
while(scanf("%d",&n) != EOF && n)
{
int flag= 0;
for(int i = 1; i <= n; i++)
{
scanf("%d",&a[i]);
}

int t = 0;
mp.clear();
for(int i = 1; i <= n; i++)
{
mp[a[i]] = 1;
//cout << mp[t] <<endl ;
while(mp.find(t) != mp.end()) t++;
mex[i] = t;
}

build(1,1,n);
mp.clear();
for(int i = n; i >= 1; i--)
{
if(mp[a[i]] == 0) nex[i] = n+1;
else nex[i] = mp[a[i]];
mp[a[i]] = i;
}
ll ans = 0;
for(int i = 1; i <= n; i++)
{
int nx = nex[i];
ans += query(1,i,n);
//cout << ans <<endl;
if(tree[1].Max > a[i])
{
get_k(1,a[i]);
if(cur < nx)
Insert(1,cur,nx-1,a[i]);
// cout << cur <<" "<<nx << " " << a[i] <<endl;
}
}
printf("%I64d\n",ans);
}
return 0;
}

/*
Sample Input
3
0 1 3
5
1 0 2 0 1
0

Sample Output 5 24
*/