Codeforces Round #204 (Div. 1) D. Jeff and Removing Periods

http://codeforces.com/problemset/problem/351/D

 

题意：

n个数的一个序列，m个操作

给出操作区间[l,r]，

首先可以删除下标为等差数列且数值相等的一些数

然后可以对区间剩余数重排

继续删除下标为等差数列且数值相等的一些数

继续对区间进行重排

直至区间内没有数

问每次操作的最少删除次数

 

因为每次删除后可以重排

那么完全可以在第一次删除后就把区间相等的数排在一起

这样相等的数的下标就分别构成了公差为1的等差数列

所以问题转化为

设区间[l,r]内数有x种，

若在区间内有一种数，他的位置下标构成等差数列，输出x

否则，输出x+1

 

本题可以离线操作

区间内数的种类，用莫队算法很容易做

所以问题只剩下如何用莫队算法维护区间内 相同的数的下标构成等差序列 的数的种数

 

思路：

加一个数：

如果这个数在区间里没有出现过，等差序列数+1

否则，若加的数破坏了原有的一个等差序列，等差序列数-1

删一个数：

如果这个数在区间里只剩下1个，等差序列数-1

否则，若删的数使原来不能构成 等差序列的数构成了等差序列，等差序列数+1

每次操作的答案=区间数的种数+ k

若等差序列数=0，则k=1，否则k=0

 

具体实现：

 

预处理fl[i],fr[i]表示第i个数左/右第一个 相等但下标不能构成等差序列的位置

为了得到这个，还需要两个数组：

pre[i]  i左边第一个和i相等的数的位置

bac[i] i右边第一个和i相等的数的位置

若pre[pre[i]]-pre[i]==i-pre[i] 或者 pre[i]==0 fl[i]=fl[pre[i]]（两个数一定是等差数列）

否则 fl[i]=pre[pre[i]]

fr同理

 

设莫队维护的当前区间为[L,R]

破坏等差数列：

若此时L正在递减，那就是fr[bac[i]]>R && fr[i]<=R

若此时R正在递增，那就是fl[pre[i]]<L && fl[i]>=L

产生等差数列：

若此时L正在递增，那就是fr[i]<=R && fr[bac[i]]>R

若此时R正在递减，那就是fl[i]>=L && fl[pre[i]]<L 

 

#include<cmath>
#include<cstdio>
#include<iostream>
#include<algorithm>

using namespace std;

#define N 100002

int val[N],last[N];
int pre[N],fl[N];
int bac[N],fr[N];

struct node
{
    int l,r;
    int id;
}e[N];

int bl[N];

int sum[N];

int ans[N];

void read(int &x)
{
    x=0; char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) { x=x*10+c-'0'; c=getchar(); }
}

bool cmp(node p,node q)
{
    if(bl[p.l]!=bl[q.l]) return bl[p.l]<bl[q.l];
    return p.r<q.r; 
}

int main()
{
    int n;
    read(n);
    int x,y;
    for(int i=1;i<=n;++i)
    {
        read(val[i]);
        pre[i]=last[val[i]];
        last[val[i]]=i;
        if(pre[pre[i]]-pre[i]==pre[i]-i || !pre[i])    fl[i]=fl[pre[i]];
        else fl[i]=pre[pre[i]];
    }    
    for(int i=1;i<=n;++i) last[i]=n+1;
    fr[n+1]=n+1;
    for(int i=n;i;--i)
    {
        bac[i]=last[val[i]];
        last[val[i]]=i;
        if(bac[bac[i]]-bac[i]==bac[i]-i || bac[i]==n+1) fr[i]=fr[bac[i]];
        else fr[i]=bac[bac[i]];
    }
    int m;
    read(m);
    for(int i=1;i<=m;++i)
    {
        read(e[i].l);
        read(e[i].r);
        e[i].id=i;
    }
    int siz=sqrt(n);
    for(int i=1;i<=n;++i) bl[i]=(i-1)/siz+1;
    sort(e+1,e+m+1,cmp);
    int L=1,R=0,tmp=0,dengcha=0;
    for(int j=1;j<=m;++j)
    {
        x=e[j].l; y=e[j].r;
    
            for(int i=L-1;i>=x;--i)
            {
                if(!sum[val[i]])
                {
                    dengcha++;
                    tmp++;
                }
                else
                {
                    if(fr[i]<=R && fr[bac[i]]>R) dengcha--;
                }
                sum[val[i]]++;
            }
            for(int i=L;i<x;++i)
            {
                if(sum[val[i]]==1)
                {
                    dengcha--;
                    tmp--;
                }
                else
                {
                    if(fr[i]<=R && fr[bac[i]]>R) dengcha++;
                }
                sum[val[i]]--; 
            }
            for(int i=R;i>y;--i)
            {
                if(sum[val[i]]==1)
                {
                    dengcha--;
                    tmp--;
                }
                else
                {
                    if(fl[i]>=x && fl[pre[i]]<x) dengcha++;
                }
                sum[val[i]]--;
            }
            for(int i=R+1;i<=y;++i)
            {
                if(!sum[val[i]])
                {
                    dengcha++;
                    tmp++;
                }
                else
                {
                    if(fl[i]>=x && fl[pre[i]]<x) dengcha--;
                }
                sum[val[i]]++;
            }
        L=x; R=y;
        ans[e[j].id]=tmp+1;
        if(dengcha>0) ans[e[j].id]--;
    }
    for(int i=1;i<=m;++i) cout<<ans[i]<<'\n';
}

 

D. Jeff and Removing Periods

time limit per test

3 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Cosider a sequence, consisting of n integers: a1, a2, ..., an. Jeff can perform the following operation on sequence a:

• take three integers v, t, k (1 ≤ v, t ≤ n; 0 ≤ k; v + tk ≤ n), such that av = av + t, av + t = av + 2t, ..., av + t(k - 1) = av + tk;
• remove elements av, av + t, ..., av + t·k from the sequence a, the remaining elements should be reindexed a1, a2, ..., an - k - 1.
• permute in some order the remaining elements of sequence a.

A beauty of a sequence a is the minimum number of operations that is needed to delete all elements from sequence a.

Jeff's written down a sequence of m integers b1, b2, ..., bm. Now he wants to ask q questions. Each question can be described with two integers li, ri. The answer to the question is the beauty of sequence bli, bli + 1, ..., bri. You are given the sequence b and all questions. Help Jeff, answer all his questions.

Input

The first line contains integer m (1 ≤ m ≤ 105). The next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 105).

The third line contains integer q (1 ≤ q ≤ 105) — the number of questions. The next q lines contain pairs of integers, i-th of them contains a pair of integers li, ri (1 ≤ li ≤ ri ≤ m) — the description of i-th question.

Output

In q lines print the answers to Jeff's queries. Print the answers according to the order of questions in input.

Examples

input

5
2 2 1 1 2
5
1 5
1 1
2 2
1 3
2 3

output

2
1
1
2
2

input

10
2 1 3 3 3 3 1 3 1 1
10
4 8
2 10
1 10
4 4
1 3
2 4
6 7
1 9
2 5
1 1

output

2
3
3
1
3
2
2
3
2
1