和弹飞绵羊类似的，那题是维护一个内向树，这题是维护若干棵基环内向树和一棵内向树

同样的用LCT维护就好了
内向树可以直接维护，对于基环内向树，随便找环上一点x做根，记录他指向哪个点to[x]
对于Cut操作，不在环上可以直接断，否则断了之后要把x和to[x]连起来
对于Link操作，如果不成环同样可以直接连，否则直接把这个Link的点当作这棵基环内向树的根就行了

询问的话，如果不在n+1那棵内向树上直接输出-1，否则答案就是他的层数

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
#define pb push_back
using namespace std;

inline void read(int &x)
{
    char c; int f=1;
    while(!((c=getchar())>='0'&&c<='9')) if(c=='-') f=-1;
    x=c-'0';
    while((c=getchar())>='0'&&c<='9') (x*=10)+=c-'0';
    if(f==-1) x=-x;
}
const int maxn = 210000;

int n,m;
int a[maxn];
struct Link_Cut_Tree
{
    int son[maxn][2],fa[maxn],siz[maxn];
    void init()
    {
        siz[0]=0;
        for(int i=1;i<=n+1;i++) siz[i]=1;
    }
    void pushup(const int x){ siz[x]=siz[son[x][0]]+siz[son[x][1]]+1; }
    bool isrt(const int x){ return son[fa[x]][0]!=x&&son[fa[x]][1]!=x; }
    void rot(int x)
    {
        int y=fa[x],z=fa[y];
        if(!isrt(y)) son[z][son[z][1]==y]=x;
        fa[x]=z;
        int l=son[y][1]==x;
        fa[son[y][l]=son[x][!l]]=y;
        fa[son[x][!l]=y]=x;
        pushup(y);
    }
    void splay(int x)
    {
        for(;!isrt(x);rot(x))
        {
            int y=fa[x],z=fa[y];
            if(!isrt(y)) rot(((son[z][1]==y)^(son[y][1]==x))?x:y);
        }pushup(x);
    }
    void Access(int x)
    {
        for(int y=0;x;y=x,x=fa[x])
        {
            splay(x); son[x][1]=y;
            pushup(x);
        }
    }
    int go(int x,int dir)
    {
        while(son[x][dir]) x=son[x][dir];
        return x;
    }
    int findrt(int x)
    {
        Access(x); splay(x);
        return go(x,0);
    }
    bool Connected(int x,int y){ return findrt(x)==findrt(y); }
    void Link(int x,int y)
    {
        splay(y); fa[y]=x;
    }
    void Cut(int x)
    {
        Access(x); splay(x);
        fa[son[x][0]]=0,son[x][0]=0,pushup(x);
    }
    int q(int x)
    {
        Access(x); splay(x);
        return siz[son[x][0]];
    }
    bool InCir(int x)
    {
        int ff=findrt(x);
        Access(a[ff]);
        splay(x);
        return go(x,0)==ff;
    }
}LCT;

int main()
{
    read(n); read(m);
    for(int i=1;i<=n;i++)
    {
        int x; read(x);
        if(i+x>n||i+x<=0) a[i]=n+1;
        else a[i]=i+x;
    }
    LCT.init();
    for(int i=1;i<=n;i++)
    {
        int y=i,x=a[i];
        if(LCT.Connected(x,y)) continue;
        else LCT.Link(x,y);
    }
    for(int i=1;i<=m;i++)
    {
        int op; read(op);
        if(op==1)
        {
            int x;read(x);
            if(!LCT.Connected(x,n+1)) puts("-1");
            else printf("%d\n",LCT.q(x));
        }
        else
        {
            int x,c; read(x); read(c);
            c=(x+c>n||x+c<=0)?n+1:x+c;
            if(LCT.Connected(x,n+1)||!LCT.InCir(x)) LCT.Cut(x);
            else if(LCT.findrt(x)!=x)
            {
                int ff=LCT.findrt(x);
                LCT.Cut(x);
                LCT.Link(a[ff],ff);
            }
            if(LCT.findrt(c)!=x) LCT.Link(c,x);
            a[x]=c; 
        }
    }

    return 0;
}