测试地址：Homework
做法：本题需要用到分块+并查集。
看到取模，一般的数据结构肯定做不了，于是考虑对权值序列分块。
首先，当模数不超过n−−√n（nn为最大数）时，我们显然可以开n−−√n个桶，每次插入暴力更新这些桶，这样答案就可以每次O(1)O(1)地求出了。
然后，当模数超过n−−√n时，它在nn之内的倍数不超过n−−√n个，那么取模后最小的数，也就是这些倍数点右边最近的点。怎么求这样的点呢？正向考虑比较麻烦，注意到题目可以离线，于是反向把加数变成减数，这样每删除一个数就意味着合并两个区间，就可以用并查集维护了。于是我们就解决了这一题，时间复杂度为O(nn−−√)O(nn)。
以下是本人代码：

#include <bits/stdc++.h>
using namespace std;
int n,blocksiz,q,op[100010],opx[100010],fa[300010];
int ans[100010],nowans[610];
bool vis[300010]={0};

int find(int x)
{
    int r=x,i=x,j;
    while(r!=fa[r]) r=fa[r];
    while(i!=r) j=fa[i],fa[i]=r,i=j;
    return r;
}

void merge(int x,int y)
{
    int fx=find(x),fy=find(y);
    if (fx>fy) swap(x,y);
    fa[fx]=fy;
}

int main()
{
    n=300000;
    blocksiz=(int)sqrt(n)+1;
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        char s[5];
        scanf("%s",s);
        if (s[0]=='A') op[i]=0;
        else op[i]=1;
        scanf("%d",&opx[i]);
    }

    for(int i=1;i<=blocksiz;i++)
        nowans[i]=n+1;
    for(int i=1;i<=q;i++)
    {
        if (!op[i])
        {
            vis[opx[i]]=1;
            for(int j=1;j<=blocksiz;j++)
                nowans[j]=min(nowans[j],opx[i]%j);
        }
        else if (opx[i]<=blocksiz)
            ans[i]=nowans[opx[i]];
    }
    int last=n+1;
    fa[n+1]=n+1;
    for(int i=n;i>=0;i--)
    {
        if (vis[i]) last=i;
        fa[i]=last;
    }
    for(int i=q;i>=1;i--)
    {
        if (!op[i]) merge(opx[i],opx[i]+1);
        else if (opx[i]>blocksiz)
        {
            ans[i]=n+1;
            for(int j=0;j<=n;j+=opx[i])
                if (find(j)!=n+1)
                    ans[i]=min(ans[i],find(j)%opx[i]);
        }
    }
    for(int i=1;i<=q;i++)
        if (op[i]) printf("%d\n",ans[i]);

    return 0;
}