#HDU 4747 Mex 【通过区间处理next变化统计总值】

题目：

Mex

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 2517    Accepted Submission(s): 816

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

    
    

     
     

      
      Hint
     
     
For the first test case:
mex(1,1)=1, mex(1,2)=2, mex(1,3)=2, mex(2,2)=0, mex(2,3)=0,mex(3,3)=0.
 1 + 2 + 2 + 0 +0 +0 = 5.

    
    
    
     
   
   

 

Source

2013 ACM/ICPC Asia Regional Hangzhou Online

 

Recommend

liuyiding

思路： Mex 是一个函数， 指定一个集合 A ，Mex(A) 为在集合A中未出现的最小的非负整数。 //例：Mex（0,1,2,5）=3

题目给定长度为N的数列，求其所有连续子串的Mex和

N最大为2*10^5 ，子串共有 k * 10 ^ 10 若枚举必然超时， 故使用DP求解。

建立一棵线段树，点 i 所存的信息为若某字串起点位置为 1 ，终点位置 为 i ，该字串的Mex值。能在O（n）时间内求出，且易得，该线段树单调递增。

线段树用于求和，则其父节点所存信息为以 1 为起点 的所有子串 Mex和。 在O（1）内求出。

接着递推DP（2），即以2为起点的所有子串Mex和。易得，在串中删去 位置为 1  的数字（设为 data[i] ）后，由于Mex单调递增，故，在下一个 data[i] 出现前，所有大于 data[i]  的值都将更新为 data[i]。

即需要另外两颗线段树，一个用于存储 对于每一个 位置，下一个与其值相同的位置在哪里 即next数组。 另一个用于求第一个大于等于 data[i] 的位置在哪里。（该操作可以使用lower_bound函数二分完成 ，效率同样为 log 级别）

迭代更新至 DP（N）

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <vector>
#include <algorithm>

#define MAXN 300001
long long t[3 * MAXN], a[3 * MAXN];
int lazy[3 * MAXN];
int lazys[3 * MAXN];
long long data[3 * MAXN];
int nexts[3 * MAXN];
long long ts[3 * MAXN];
int n;

using namespace std;

void BuildTree(int l, int r, int x){
	if (l == r)
	{
		t[x] = a[l];
		return;
	}
	int m = (l + r) >> 1;
	BuildTree(l, m, x << 1);
	BuildTree(m + 1, r, x << 1 | 1);
	t[x] = t[x << 1] + t[x << 1 | 1];
	return;
}

void PushDown(int l, int r, int x){
	int m = (l + r) >> 1;
	if (lazy[x] != -1){
		t[x << 1] = lazy[x] * (m - l + 1);
		t[x << 1 | 1] = lazy[x] * (r - m);
		lazy[x << 1 | 1] = lazy[x];
		lazy[x << 1] = lazy[x];
		lazy[x] = -1;
	}
	return;
}

void Modify(int pos, int val, int l, int r, int x){
	if (pos == l && r == l)
	{
		t[x] += val;
		return;
	}
	int m = (l + r) >> 1;
	if (pos <= m)
	{
		Modify(pos, val, l, m, x << 1);
	}
	else Modify(pos, val, m + 1, r, x << 1 | 1);
	t[x] = t[x << 1] + t[x << 1 | 1];
	return;
}

long long Query(int L, int R, int l, int r, int x){
	if (L == l && R == r)
		return t[x];
	PushDown(l, r, x);
	int m = (l + r) >> 1;
	if (R <= m)return Query(L, R, l, m, x << 1);
	else if (L>m)return Query(L, R, m + 1, r, x << 1 | 1);
	else return Query(L, m, l, m, x << 1) + Query(m + 1, R, m + 1, r, x << 1 | 1);
}


void SegModify(int L, int R, int val, int l, int r, int x){
	if (l == L&&r == R){
		t[x] = (R - L + 1)*val;
		lazy[x] = val;
		return;
	}
	PushDown(l, r, x);
	int m = (l + r) >> 1;
	if (R <= m)SegModify(L, R, val, l, m, x << 1);
	else if (L>m)SegModify(L, R, val, m + 1, r, x << 1 | 1);
	else {
		SegModify(L, m, val, l, m, x << 1);
		SegModify(m + 1, R, val, m + 1, r, x << 1 | 1);
	}
	t[x] = t[x << 1] + t[x << 1 | 1];
	return;
}


void BuildTrees(int l, int r, int x){
	if (l == r)
	{
		ts[x] = a[l];
		return;
	}
	int m = (l + r) >> 1;
	BuildTrees(l, m, x << 1);
	BuildTrees(m + 1, r, x << 1 | 1);
	ts[x] = max(ts[x << 1], ts[x << 1 | 1]);
	return;
}

void PushDowns(int l, int r, int x){
	int m = (l + r) >> 1;
	if (lazys[x] != -1){
		ts[x << 1] = lazys[x];
		ts[x << 1 | 1] = lazys[x];
		lazys[x << 1 | 1] = lazys[x];
		lazys[x << 1] = lazys[x];
		lazys[x] = -1;
	}
	return;
}

void Modifys(int pos, int val, int l, int r, int x){
	if (pos == l && r == l)
	{
		ts[x] += val;
		return;
	}
	int m = (l + r) >> 1;
	if (pos <= m)
	{
		Modifys(pos, val, l, m, x << 1);
	}
	else Modifys(pos, val, m + 1, r, x << 1 | 1);
	ts[x] = max(ts[x << 1], ts[x << 1 | 1]);
	return;
}

long long Querys(int L, int R, int l, int r, int x){
	if (L == l && R == r)
		return ts[x];
	PushDowns(l, r, x);
	int m = (l + r) >> 1;
	if (R <= m)return Querys(L, R, l, m, x << 1);
	else if (L>m)return Querys(L, R, m + 1, r, x << 1 | 1);
	else return max(Querys(L, m, l, m, x << 1), Querys(m + 1, R, m + 1, r, x << 1 | 1));
}


void SegModifys(int L, int R, int val, int l, int r, int x){
	if (l == L&&r == R){
		ts[x] = val;
		lazys[x] = val;
		return;
	}
	PushDowns(l, r, x);
	int m = (l + r) >> 1;
	if (R <= m)SegModifys(L, R, val, l, m, x << 1);
	else if (L>m)SegModifys(L, R, val, m + 1, r, x << 1 | 1);
	else {
		SegModifys(L, m, val, l, m, x << 1);
		SegModifys(m + 1, R, val, m + 1, r, x << 1 | 1);
	}
	ts[x] = max(ts[x << 1], ts[x << 1 | 1]);
	return;
}

int finds(int val, int l, int r, int x)
{
	if (l == r)
	{
		return l;
	}
	PushDowns(l, r, x);
	if (ts[x << 1] >= val)
	{
		return finds(val, l, (l + r) / 2, x << 1);
	}
	else if (ts[x << 1 | 1] >= val)
	{
		return finds(val, (l + r) / 2 + 1, r, x << 1 | 1);
	}
	else
	{
		return n + 1;
	}
}

int main()
{


	int nn, mm;
	while (cin >> nn)
	{
		long long ans = 0;
		if (nn == 0)
		{
			return 0;
		}
		n = 1;
		while (n < nn)
		{
			n *= 2;
		}
		memset(t, 0, sizeof(t));
		memset(lazy, -1, sizeof(lazy));
		memset(lazys, -1, sizeof(lazys));
		for (size_t i = 1; i <= nn; i++)
		{
			scanf("%d", &data[i]);
			if (data[i]>200000)
			{
				data[i] = 200001;
			}
		}
		int bes = 0;

		for (size_t i = 0; i <= n * 2 + 1; i++)
		{
			a[i] = -1;
		}
		for (size_t i = 1; i <= nn; i++)
		{
			t[data[i]] = 1;
			while (t[bes])
			{
				bes++;
			}
			a[i] = bes;
		}
		memset(t, 0, sizeof(t));
		BuildTrees(1, n, 1);

		bes = 0;

		memset(a, 0, sizeof(a));
		for (size_t i = 1; i <= nn; i++)
		{
			t[data[i]] = 1;
			while (t[bes])
			{
				bes++;
			}
			a[i] = bes;
		}
		memset(t, 0, sizeof(t));
		for (size_t i = 1; i <= nn; i++)
		{
			nexts[i] = nn + 1;
		}
		for (size_t i = 1; i <= nn; i++)
		{
			nexts[t[data[i]]] = i;
			t[data[i]] = i;
		}
		memset(t, 0, sizeof(t));
		BuildTree(1, n, 1);

		ans += Query(1, n, 1, n, 1);

		for (size_t i = 1; i < nn; i++)
		{
			int tofind = data[i];
			SegModify(i, i, -1, 1, n, 1);
			SegModifys(i, i, -1, 1, n, 1);

			int mid;
			mid = finds(tofind, 1, n, 1);

			if (mid<nexts[i])
			{
				SegModify(mid, nexts[i] - 1, data[i], 1, n, 1);
				SegModifys(mid, nexts[i] - 1, data[i], 1, n, 1);
			}
			ans += Query(i + 1, nn, 1, n, 1);
		}

		cout << ans << "\n";
	}
	return 0;
}