NYOJ133子序列（坐标离散化）

子序列

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 5

描述

给定一个序列，请你求出该序列的一个连续的子序列，使原串中出现的所有元素皆在该子序列中出现过至少1次。

如2 8 8 8 1 1，所求子串就是2 8 8 8 1。

输入

第一行输入一个整数T(0<T<=5)表示测试数据的组数
每组测试数据的第一行是一个整数N(1<=N<=1000000)，表示给定序列的长度。
随后的一行有N个正整数，表示给定的序列中的所有元素。
数据保证输入的整数都不会超出32位整数的范围。

输出

对于每组输入，输出包含该序列中所有元素的最短子序列的长度

样例输入

2
5
1 8 8 8 1
6
2 8 8 8 1 1

样例输出

2
5

思路，求一个连续的子序列包含所有出现过的数据，可以先找出一共有多少种元素，然后用一个数组来标记每个元素出现的个数，素质的下标就代表着一个元素。然后从1~n开始遍历，当所有的元素都出现时记录当前子序列的长度，继续遍历，找出最小的子序列长度，相信很多人都能想到这一步，但是题目说了整数的范围为32位以内，开数组毫无疑问会超内存，那么怎么办呢，仔细观察输入的数据N范围为1~1000000,则可以说明虽然数据的范围为32位以内，但是并不是每个整数都会被用到，最多会有1000000个整数会被用到，这时候我们就可以用坐标离散化来解决这个问题。

什么是坐标离散化？

  拿题目的第一条数据简单的举个例子。

一共有2种元素，1,8.如果要用数组标记的话数组的长度至少要开到8.

但是如果把1标记1，把8标记为2的话，数组只需要开到2就行了。。

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct Node
{
	int x;
	int i;	
}node[1000010];
int a[1000010];
int v[1000010];
int c[1000010];  
int id;
int comp(Node n1,Node n2)
{
	return n1.x<n2.x;
}
int main()
{
	int t,n,i,j,cnt,res,min;
	scanf("%d",&t);
	while(t--)
	{
		id=0;
		cnt=0;
		res=100000009;
		min=0;
		memset(c,0,sizeof(c));
		scanf("%d",&n);
		for(i=1;i<=n;i++)
		{
			scanf("%d",&node[i].x);
			node[i].i=i;
		}
		sort(node+1,node+1+n,comp);
		v[node[1].i]=++id;
		for(i=2;i<=n;i++)
		{
			if(node[i].x==node[i-1].x)
			{
				v[node[i].i]=id;
			}
			else
			{
				v[node[i].i]=++id;
			}
		}
		for(i=1;i<=n;i++)
		{
			min++;
			if(c[v[i]]==0)
			{
				cnt++;
			}
			c[v[i]]++;
			while(cnt>=id)
			{
				res=res<min?res:min;
				if(--c[v[i-min+1]]==0)
				{
					cnt--;
				}
				min--;	
			}
		}
		printf("%d\n",res);
	}
	return 0;
}