uva 11572 唯一的雪花 Unique Snowflakes

输入一个长度为n(n<=1e6)的序列A，找到一个尽量长的连续子序列AL~AR,使得该序列中没有相同元素。输出最大长度。

核心是:

对数据处理类似与一个队列的结构，队头front,队尾rear,两个都可以不断增加，比如rear增加1，那么为了保证同一个元素不在队列里出现两次,可能会出队一些元素。

或者可以这么解释，对于每一个值x，记录前一个值x出现的位置last[x]，所以考虑x进入序列时，last[x]及以前的元素不得考虑。

具体实现：

数据结构的选择有很多种，不管是用map还是set还是自己定义的结构体都是可以的。

我自己写的稍微麻烦点，离散化+队列处理。

离散化：先排序，然后用存储每个数值的映射值,o(nlogn)。其实这个作法相当于用map作为存储结构。

用set是很自然的想法，因为扫描的顺序是从左往右，所有set只用记录每个元素是否出现即可。

不管是枚举rear所在位置[0,n)还是front所在位置[0,n)都是可以的

/**==========================================
 *   This is a solution for ACM/ICPC problem
 *
 *   @source£º
 *   @type:
 *   @author: wust_ysk
 *   @blog:  http://blog.csdn.net/yskyskyer123
 *   @email: 2530094312@qq.com
 *===========================================*/
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#define REP(i,n)  for(int i=0 ;i<(n) ;i++)
using namespace std;
typedef long long ll;
const int INF =0x3f3f3f3f;
const int maxn= 1000000   ;
struct Node
{
    int ind,x,y;
    bool operator<(const Node b)const
    {
        return ind<b.ind;
    }

}a[maxn+4];

bool cmp(Node c,Node b)
{
    return c.x<b.x;
}
int n;

struct MyQueue
{
    int front,rear;
    bool vis[maxn+4];
    void clear()
    {
        front=rear=0;
        memset(vis,0,n*sizeof vis[0]);
    }
    int size()
    {
        return rear-front;
    }
    void push(int y)
    {
        if(!vis[y])
        {
            rear++;
            vis[y]=1;
            return;
        }
        while(a[front].y!=y )
        {
            vis[a[front].y]=0;
            front++;
        }
        front++;
        rear++;

    }

}Q;
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        REP(i,n)
        {
            scanf("%d",&a[i].x);
            a[i].ind=i;
        }
        sort(a,a+n,cmp);
        REP(i,n)
        {
            a[i].y=i;
            int t=i;
            while(i+1<n&&a[i+1].x==a[i].x)
            {
                a[++i].y=t;
            }
        }
        sort(a,a+n);
        Q.clear();
        int ans=0;
        REP(i,n)
        {
            int y=a[i].y;
            Q.push(y);
            ans=max(ans,Q.size());
        }
        printf("%d\n",ans);
    }

   return 0;
}