Codeforces Round #366 (Div. 2) C. Thor

题目链接： 点击打开链接
C. Thor

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Thor is getting used to the Earth. As a gift Loki gave him a smartphone. There aren applications on this phone. Thor is fascinated by this phone. He has only one minor issue: he can't count the number of unread notifications generated by those applications (maybe Loki put a curse on it so he can't).

q events are about to happen (in chronological order). They are of three types:

1. Application x generates a notification (this new notification is unread).
2. Thor reads all notifications generated so far by application x (he may re-read some notifications).
3. Thor reads the first t notifications generated by phone applications (notifications generated in firstt events of the first type). It's guaranteed that there were at leastt events of the first type before this event. Please note that he doesn't read firstt unread notifications, he just reads the very firstt notifications generated on his phone and he may re-read some of them in this operation.

Please help Thor and tell him the number of unread notifications after each event. You may assume that initially there are no notifications in the phone.

Input

The first line of input contains two integers n andq (1 ≤ n, q ≤ 300 000) — the number of applications and the number of events to happen.

The next q lines contain the events. Thei-th of these lines starts with an integertype_i — type of thei-th event. If type_i = 1 ortype_i = 2 then it is followed by an integerx_i. Otherwise it is followed by an integert_i (1 ≤ type_i ≤ 3, 1 ≤ x_i ≤ n, 1 ≤ t_i ≤ q).

Output

Print the number of unread notifications after each event.

Examples

Input

3 4
1 3
1 1
1 2
2 3

Output

1
2
3
2

Input

4 6
1 2
1 4
1 2
3 3
1 3
1 3

Output

1
2
3
0
1
2

题目大意：

n是应用数量，q是操作数量 （n,q<=300000）

给你三种操作：

1 x：表示第x个应用发出一条推送。

2 x：表示读完第x个应用发出的所有推送（有可能重复读一条推送）。

3 x：表示读完前x条推送（也有可能重复读一条推送）。

每进行一次操作，问当前未读的推送；

思路：暴力的复杂度有O（n*q）,

           容易看出，对于第二种操作，只要开一个数组记录第x个应用已经读的推送个数，再对比这个应用所有推送个数就能得到答案。但是由于第三种操作的存在，多了一种读取推送的方式，上述方法错误。

           但我们可以肯定当前第二种操作读取的推送个数（q）肯定不需要考虑第x个应用之前第二种操作已经读取的推送个数（w），那么再考虑在w+1到q之间的推送是否已经被第三种操作读取过，那么问题转到第三种操作上，同理第三种操作也是考虑现在的x与之前第三种操作额最大值y的比较，如果x>y那么就要考虑在y+1到x之前的推送受到第二种操作的影响。所以只要开一个vis数组，记录是否当前推送被访问就可以了。但是无论如何，对于每种操作所有推送只会被访问一遍，所以就是o（n）的时间。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N=300005;
int head[N];
bool vis[N];
int n,cnt;
struct Edge
{
    int next,v;
};
Edge edge[N];
void add(int u,int v)
{
    edge[cnt].next=head[u];
    edge[cnt].v=v;
    head[u]=cnt++;
}
int main()
{
    int q,a,b,number=0,use=0,prelen=0,flag,cnt=0;
    memset(head,-1,sizeof(head));
    scanf("%d %d",&n,&q);
    for(int i=1;i<=q;i++)
    {
        scanf("%d%d",&a,&b);
        if(a==1)
        {
            number++;
            add(b,number);
            printf("%d\n",number-use);
            continue;
        }
        if(a==2)
        {
            for(int j=head[b];j!=-1;j=edge[j].next)
            {
                flag=edge[j].v;
                if(!vis[flag])
                {
                    use++;
                    vis[flag]=true;
                }
            }
            head[b]=-1;                //清除之前所有存在的对于b这个应用的推送 即 消除之前所有边
            printf("%d\n",number-use);
            continue;
        }
        for(int j=prelen+1;j<=b;j++)
        {
            if(!vis[j])
            {
                use++;
                vis[j]=true;
            }
        }
        prelen=max(prelen,b);       // 取第三种操作的最大值
        printf("%d\n",number-use);
    }
    return 0;
}