首先看到这样的数据范围我们可以考虑分块，具体来说，对于每一块我们记录其中的括号是否能完全消掉，以及对其进行括号相消之后的括号序列（显然是一段右括号接上一段左括号）长什么样，那么对于一个块，我们显然可以在 (mathcal O(sqrt{n})) 的时间内对其求出其进行重构，因此每次修改完都重构一遍复杂度是不会出现问题的。
接下来考虑怎样查询一个区间是否是合法的括号序列，对于此题而言比较恶心的一点是，当我们合并两个块 (x,y) 时，要对两个块中间的部分进行括号相消时暴力跑复杂度是 (sqrt{n}) 地，再加上总共查询可能会达到 (sqrt{n}) 个块，单次查询的复杂度又退化到了 (mathcal O(n))，稳稳地 T 掉。一种解决方法是指针，可作为一名从刚学 OI 开始就不喜欢指针的选手自然是不会选择这样的写法的，因此这里介绍一种不用指针的写法。考虑我们暴力合并的过程，对于一个块而言我们肯定是先用这一块的一段右括号去消前面的一段左括号，再加入一段右括号，而如果我们把每次加入的一段右括号视为一个连续段的话，那么每次消除左括号时最多将一个左括号的连续段劈成两段。这样思路不就出来了吗，我们考虑对于每一块，将这一块消除后剩余的左括号压入一个 vector，并用一个三元组 ((x,l,r)) 描述一个连续段，表示这个连续段是第 (x) 块消除后剩余的左括号序列的第 (l) 至第 (r) 个元素，然后我们维护一个栈存储这些三元组存储这些未消完的括号组成的连续段，这样每次与一段长度为 (L) 的右括号序列进行消除时只需取出栈顶的 (L) 个元素，哈希判断括号序列是否相等即可，如果最后一段消完后还有剩余就将剩余部分压入栈中。根据之前的推论，每个三元组恰好进出栈各一次，而每次消除最多增加一个三元组，因此总复杂度是严格 (mathcal O(msqrt{n})) 的。
细节有一点点多，不过相信聪明的读者们定能够将每种情况都分析清楚（
const int MAXN=1e5;
const int BLK=316;
const u64 B=191;
u64 pw[MAXN+5];
int n,k,qu,a[MAXN+5],blk_cnt,blk_sz;
int bel[MAXN+5],L[BLK+5],R[BLK+5];
bool ok[BLK+5];
vector<int> lft[BLK+5],rit[BLK+5];
vector<u64> lft_hs[BLK+5];u64 rit_hs[BLK+5];
struct node{int x,l,r;u64 hs;};
u64 gethash(int x,int l,int r){
return (lft_hs[x][l]-((r+1==lft[x].size())?0:lft_hs[x][r+1]*pw[r-l+1]));
}
void redone(int x){
stack<int> stk;ok[x]=1;lft[x].clear();rit[x].clear();
for(int i=L[x];i<=R[x];i++){
if(a[i]<0){
if(!stk.empty()&&stk.top()^(-a[i])) return ok[x]=0,void();
else if(stk.empty()) rit[x].pb(-a[i]);else stk.pop();
} else stk.push(a[i]);
} while(!stk.empty()) lft[x].pb(stk.top()),stk.pop();
lft_hs[x].resize(lft[x].size(),0);rit_hs[x]=0;
for(int i=(int)(lft[x].size())-1;~i;i--) lft_hs[x][i]=((i+1==lft[x].size())?0:lft_hs[x][i+1])*B+lft[x][i];
for(int i=0;i<rit[x].size();i++) rit_hs[x]+=rit[x][i]*pw[i];
// printf("Block %d:
",x);
// for(int i=0;i<lft[x].size();i++) printf("%d ",lft[x][i]);printf("
");
// for(int i=0;i<rit[x].size();i++) printf("%d ",rit[x][i]);printf("
");
}
bool query(int l,int r){
if(bel[l]==bel[r]){
stack<int> stk;
for(int i=l;i<=r;i++){
if(a[i]<0){
if(stk.empty()||stk.top()^(-a[i])) return 0;
stk.pop();
} else stk.push(a[i]);
} return stk.empty();
} for(int i=bel[l]+1;i<bel[r];i++) if(!ok[i]) return 0;
stack<node> stk;
for(int i=l;i<=R[bel[l]];i++){
if(a[i]<0){
if(stk.empty()) return 0;node t=stk.top();stk.pop();
u64 hs=(!~t.l)?t.hs:gethash(t.x,t.l,t.l);if(hs+a[i]) return 0;
if(t.l^t.r) stk.push({t.x,t.l+1,t.r,gethash(t.x,t.l+1,t.r)});
} else stk.push({bel[l],-1,-1,a[i]});
}
for(int i=bel[l]+1;i<bel[r];i++){
int need=rit[i].size(),clen=0;u64 cur_hs=0;
while(!stk.empty()&&need){
node t=stk.top();stk.pop();int len=t.r-t.l+1;
if(need<=len){
if(!~t.l) cur_hs+=t.hs*pw[clen];
else cur_hs+=gethash(t.x,t.l,t.l+need-1)*pw[clen];
if(need^len) stk.push({t.x,t.l+need,t.r,gethash(t.x,t.l+need,t.r)});
need=0;break;
} else {
cur_hs+=t.hs*pw[clen];
need-=len;clen+=len;
}
} if(need) return 0;if(cur_hs^rit_hs[i]) return 0;
if(!lft[i].empty()) stk.push({i,0,lft[i].size()-1,lft_hs[i][0]});
}
for(int i=L[bel[r]];i<=r;i++){
if(a[i]<0){
if(stk.empty()) return 0;node t=stk.top();stk.pop();
u64 hs=(!~t.l)?t.hs:gethash(t.x,t.l,t.l);if(hs+a[i]) return 0;
if(t.l^t.r) stk.push({t.x,t.l+1,t.r,gethash(t.x,t.l+1,t.r)});
} else stk.push({bel[l],-1,-1,a[i]});
} return stk.empty();
}
int main(){
scanf("%d%d",&n,&k);
for(int i=(pw[0]=1);i<=n;i++) pw[i]=pw[i-1]*B;
blk_cnt=(int)pow(n,0.5);blk_sz=(n-1)/blk_cnt+1;
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=blk_cnt;i++){
L[i]=(i-1)*blk_sz+1;R[i]=min(i*blk_sz,n);
// printf("%d %d
",L[i],R[i]);
for(int j=L[i];j<=R[i];j++) bel[j]=i;
}
for(int i=1;i<=blk_cnt;i++) redone(i);
scanf("%d",&qu);
while(qu--){
int opt;scanf("%d",&opt);
if(opt==1){
int p,x;scanf("%d%d",&p,&x);a[p]=x;
redone(bel[p]);
} else {
int l,r;scanf("%d%d",&l,&r);
printf("%s
",query(l,r)?"Yes":"No");
}
}
return 0;
}
/*
10 10
4 4 4 -4 1 -1 -4 8 -8 -4
1
2 2 9
10 1
9 3 7 -7 4 -4 -3 1 -1 -9
1
2 1 10
*/