text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9+10;
const ll inf_ll = 1e18+10;
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define cmax(x, y) (x = max(x, y))
#define cmin(x, y) (x = min(x, y))
#ifndef LOCAL
#define debug(...) 0
#else
#include "../../debug.cpp"
#endif
const int N = 100005, B = 400;
int b[N], p[N], ps[N], f[N];
int n;
// O(BlogB)
void sort_block(int x) {
int l = x*B, r = min(n-1, (x+1)*B-1);
copy(p+l, p+r+1, ps+l);
sort(ps+l, ps+r+1);
for (int i = l; i <= r; i++)
ps[i] -= i-l;
}
// O(B^2)
void compute_block(int x) {
int l = x*B, r = min(n-1, (x+1)*B-1);
for (int i = r; i >= l; i--) {
p[i] = b[i];
for (int j = i+1; j <= r; j++)
if (b[j] <= p[i]) p[i]++;
}
sort_block(x);
}
// O(BlogB)
void edit_block(int i, int y) {
int x = i/B;
int l = x*B, r = min(n-1, (x+1)*B-1);
// recompute p[i]
int pre = p[i];
p[i] = y;
for (int j = i+1; j <= r; j++)
if (b[j] <= p[i]) p[i]++;
// cycle j < i
for (int j = i+1; j <= r; j++)
f[p[j]] = 1;
if (y > b[i]) {
for (int j = l; j < i; j++)
if (p[j] >= pre && p[j] <= p[i]) {
p[j]--;
while (f[p[j]]) p[j]--;
}
} else {
for (int j = l; j < i; j++)
if (p[j] <= pre && p[j] >= p[i]) {
p[j]++;
while (f[p[j]]) p[j]++;
}
}
b[i] = y;
for (int j = i+1; j <= r; j++)
f[p[j]] = 0;
sort_block(x);
}
// O(logB)
int apply_block(int x, int y) {
int l = x*B, r = min(n-1, (x+1)*B-1);
return y+upper_bound(ps+l, ps+r+1, y)-(ps+l);
}
// O(N/B logB)
int query(int i) {
int y = p[i];
for (int j = i/B+1; B*j < n; j++)
y = apply_block(j, y);
return y;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> b[i], b[i] = i-b[i];
for (int i = 0; B*i < n; i++)
compute_block(i);
int q; cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int i, x; cin >> i >> x;
edit_block(i-1, i-1-x);
} else {
int i; cin >> i;
cout << query(i-1)+1 << "\n";
}
}
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=600,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
cnt[k].add(mn[i],-1);
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+cnt[k].f[mn[i]]<rmd[i]+d)
{
rmd[i]=rmd[i]-cnt[k].f[mn[i]]+d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]-1+d>=rmd[i])
{
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
/*
Author: QAQAutoMaton
Lang: C++
Code: D.cpp
Mail: lk@qaq-am.com
Blog: https://www.qaq-am.com/
*/
#include<bits/stdc++.h>
#define debug(qaq...) fprintf(stderr,qaq)
#define DEBUG printf("Passing [%s] in LINE %d\n",__FUNCTION__,__LINE__)
#define Debug debug("Passing [%s] in LINE %d\n",__FUNCTION__,__LINE__)
#define all(x) x.begin(),x.end()
#define x first
#define y second
#define unq(a) sort(all(a)),a.erase(unique(all(a)),a.end())
using namespace std;
typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef complex<double> cp;
typedef pair<int,int> pii;
int inf;
const double eps=1e-8;
const double pi=acos(-1.0);
template<class T,class T2>int chkmin(T &a,T2 b){return a>b?a=b,1:0;}
template<class T,class T2>int chkmax(T &a,T2 b){return a<b?a=b,1:0;}
template<class T>T sqr(T a){return a*a;}
template<class T,class T2>T mmin(T a,T2 b){return a<b?a:b;}
template<class T,class T2>T mmax(T a,T2 b){return a>b?a:b;}
template<class T>T aabs(T a){return a<0?-a:a;}
template<class T>int dcmp(T a,T b){return a>b;}
template<int *a>int cmp_a(int x,int y){return a[x]<a[y];}
template<class T>bool sort2(T &a,T &b){return a>b?swap(a,b),1:0;}
#define min mmin
#define max mmax
#define abs aabs
struct __INIT__{
__INIT__(){
fill((unsigned char*)&inf,(unsigned char*)&inf+sizeof(inf),0x3f);
}
}__INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
// getchar
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
// print the remaining part
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
// putchar
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<typename A>
inline bool read (A &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;else if(c==EOF)return 0;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15); x *= f;
return 1;
}
inline bool read (char &x) {
while((x=gc())==' '||x=='\n' || x=='\r');
return x!=EOF;
}
inline bool read(char *x){
while((*x=gc())=='\n' || *x==' '||*x=='\r');
if(*x==EOF)return 0;
while(!(*x=='\n'||*x==' '||*x=='\r'||*x==EOF))*(++x)=gc();
*x=0;
return 1;
}
template<typename A,typename ...B>
inline bool read(A &x,B &...y){
return read(x)&&read(y...);
}
template<typename A>
inline bool write (A x) {
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
return 0;
}
inline bool write (char x) {
putc(x);
return 0;
}
inline bool write(const char *x){
while(*x){putc(*x);++x;}
return 0;
}
inline bool write(char *x){
while(*x){putc(*x);++x;}
return 0;
}
template<typename A,typename ...B>
inline bool write(A x,B ...y){
return write(x)||write(y...);
}
//no need to call flush at the end manually!
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: read;
using io :: putc;
using io :: write;
int b[100005];
const int B=200;
int blk[100005];
int st[100005],ed[100005];
vector<int> xblk[100005];
int w[100005];
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
namespace fhq{
int ls[200005],rs[200005],v[200005],w[200005],tag[200005];
int rv[200005];
int t,rt;
int stk[200005],tp;
bitset<200005>del;
int newNode(int x){
++t;
ls[t]=rs[t]=0;
v[t]=x;w[t]=rnd();
return t;
}
void put_tag(int x,int y){
if(x){v[x]+=y;tag[x]+=y;}
}
void push_down(int x){
if(tag[x]){
put_tag(ls[x],tag[x]);put_tag(rs[x],tag[x]);
tag[x]=0;
}
}
void split(int rt,int w,int &r1,int &r2){
if(!rt){r1=r2=0;return;}
push_down(rt);
if(v[rt]<=w){
r1=rt;
split(rt[rs],w,r1[rs],r2);
}
else{
r2=rt;
split(rt[ls],w,r1,r2[ls]);
}
}
int merge(int r1,int r2){
if(!r2)return r1;
if(!r1)return r2;
if(w[r1]<w[r2]){
push_down(r1);
r1[rs]=merge(r1[rs],r2);
return r1;
}
else{
push_down(r2);
r2[ls]=merge(r1,r2[ls]);
return r2;
}
}
void output(int x,vector<int> &out,int &cur){
push_down(x);
if(ls[x])output(ls[x],out,cur);
out[cur]=v[x];++cur;
if(rs[x])output(rs[x],out,cur);
}
}
void build(int x){
int l=st[x],r=ed[x];
fhq::t=0;fhq::rt=fhq::newNode(b[r]);
int c=1;
int r1,r2;
for(int i=r-1;i>=l;--i){
fhq::split(fhq::rt,b[i],r1,r2);
int v=fhq::newNode(b[i]);
fhq::put_tag(r2,-1);
fhq::rt=fhq::merge(r1,fhq::merge(v,r2));
}
int cur=0;
xblk[x].resize(fhq::t);
fhq::output(fhq::rt,xblk[x],cur);
}
signed main(){
#ifdef QAQAutoMaton
freopen("D.in","r",stdin);
freopen("D.out","w",stdout);
#endif
int n;
read(n);
for(int i=1;i<=n;++i){
read(b[i]);
b[i]=i-b[i];
blk[i]=(i-1)/B+1;
ed[blk[i]]=i;
if(!st[blk[i]])st[blk[i]]=i;
}
for(int i=1;i<=blk[n];++i)build(i);
int q;
read(q);
for(;q;--q){
int tp,x,y;
read(tp,x);
if(tp==1){
read(b[x]);b[x]=x-b[x];
build(blk[x]);
}
else{
int y=b[x];
if(x<n){
for(int i=x+1;i<=ed[blk[x+1]];++i)if(y>=b[i])++y;
for(int i=blk[x+1]+1;i<=blk[n];++i)y+=upper_bound(all(xblk[i]),y)-xblk[i].begin();
}
write(y,'\n');
}
}
return 0;
}
|
// author: xay5421
// created: Sat Jun 26 00:19:30 2021
#ifdef xay5421
#define D(...) fprintf(stderr,__VA_ARGS__)
#else
#define D(...) ((void)0)
//#define NDEBUG
#endif
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define per(i,a,b) for(int i=(a);i>=(b);--i)
using namespace std;
const int N=100005,B=200;
int n,Q,b[N],bl[N],br[N],bel[N];
struct BIT{
int t[N+5],st[B+5][2],top;
void upd(int k1,int k2){
st[++top][0]=k1,st[top][1]=k2;
for(int i=k1;i<=n;i+=i&-i)t[i]+=k2;
}
int qry(int k1){
int k2=0;
for(int i=k1;i;i&=i-1)k2+=t[i];
return k2;
}
void init(){
rep(i,1,n)t[i]=1;
rep(i,1,n)if(i+(i&-i)<=n)t[i+(i&-i)]+=t[i];
}
void clear(){
while(top){
upd(st[top][0],-st[top][1]);
top-=2;
}
}
}t[N/B+5];
void reb(int bb){
t[bb].clear();
rep(i,bl[bb],br[bb]){
int x=i-b[i],now=0,val=0;
per(j,16,0)if(now+(1<<j)<=n&&val+t[bb].t[now+(1<<j)]<x){
val+=t[bb].t[now+(1<<j)];
now+=1<<j;
}
if(now<n){
t[bb].upd(now+1,1);
}
}
}
void mdf(int k1,int k2){
b[k1]=k2;
reb(bel[k1]);
}
int sol(int pos){
int bb=bel[pos];
int x=pos-b[pos];
rep(i,pos+1,br[bb]){
if(x>=i-b[i])++x;
}
rep(i,bb+1,bel[n]){
x=t[i].qry(x);
}
return x;
}
int main(){
#ifdef xay5421
freopen("a.in","r",stdin);
#endif
scanf("%d",&n);
rep(i,1,n){
scanf("%d",&b[i]),bel[i]=(i-1)/B+1;
if(!bl[bel[i]])bl[bel[i]]=i;
br[bel[i]]=i;
}
rep(i,1,bel[n])t[i].init(),reb(i);
scanf("%d",&Q);
rep(i,1,Q){
D("i=%d\n",i);
int t;
scanf("%d",&t);
if(t==1){
int pos,x;
scanf("%d%d",&pos,&x);
mdf(pos,x);
}else{
int x;
scanf("%d",&x);
int ans=sol(x);
printf("%d\n",ans);
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define forg(i,x) for(register int i=fir[x];i;i=nxt[i])
#define uu unsigned
#define scanf a14=scanf
#define rint register int
#define fre(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout)
typedef long long ll;
typedef uu long long ull;
typedef pair<int,int>pii;
int a14;
inline int rd(int l,int r){return rand()%(r-l+1)+l;}
const int mxn=1e5+3,sq=250,qs=320;
int n,b[mxn],lp[mxn],rp[mxn],kn,be[mxn],po[mxn],qn;
int ju[mxn/sq+2][mxn],ad[mxn/sq+2][mxn/qs+1];
int TG;
struct shu{
int a[mxn],tg[mxn];
void add(int x){for(;x<=n;x+=x&-x){if(tg[x]!=TG)tg[x]=TG,a[x]=0;++a[x];}}
int ask(int x){
int su=0,p=0;
for(int i=1<<16;i;i>>=1){
if(p+i>=n)continue;
p+=i;if(tg[p]!=TG)tg[p]=TG,a[p]=0;
if(p+a[p]+su>=x)p-=i;else su+=a[p];
}
return p+1;
}
void gb(int t){for(int i=1;i<=n;++i){if(tg[i]!=TG)a[i]=0;ju[t][i]=ju[t][i-(i&-i)]+a[i];}for(int i=1;i<=n;++i)ju[t][i]+=i;}
}ar;
void add2(int t,int x,int y){
int k=(x-1)/qs;
for(int i=x;i<=(k+1)*qs;++i)ju[t][i]+=y;
for(++k;k*qs+1<=n;++k)ad[t][k]+=y;
}
int main(){
//cout<<(sizeof(ju)>>20)<<endl;
scanf("%d",&n);for(int i=1;i<=n;++i)scanf("%d",b+i),b[i]=i-b[i];scanf("%d",&qn);
for(int l=1,r;r!=n;l=r+1){r=min(l+sq-1,n);lp[++kn]=l,rp[kn]=r;for(int i=l;i<=r;++i)be[i]=kn;}
for(int t=1;t<=kn;++t){
++TG; for(int i=lp[t];i<=rp[t];++i)po[i]=ar.ask(b[i]),ar.add(po[i]);
ar.gb(t);
}
while(qn--){
int o,x,y;scanf("%d%d",&o,&x);if(o==1){
scanf("%d",&y);b[x]=x-y;int k=be[x],ls;
++TG;for(int i=lp[k];i<=rp[k];++i){
if(i<x)ar.add(po[i]);else{
ls=po[i],po[i]=ar.ask(b[i]),ar.add(po[i]);
if(ls==po[i])continue;
if(ls==po[i]-1){--ju[k][ls];continue;}
if(ls==po[i]+1){++ju[k][po[i]];continue;}
assert(i==x);
add2(k,ls,-1),add2(k,po[i],1);
}
}
}else{
int t=be[x],re=b[x];for(int i=x+1;i<=rp[t];++i)re+=b[i]<=re;
for(++t;t<=kn;++t)re=ju[t][re]+ad[t][(re-1)/qs];
printf("%d\n",re);
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define reg register
#define int long long
#define For(i,a,b) for(reg int i=a;i<=b;++i)
#define Down(i,a,b) for(reg int i=a;i>=b;--i)
#define ull unsigned long long
#define rep(i,a,b) for(reg int i=a;i<=b;++i)
#define ll long long
inline int max(int x,int y){return x>y?x:y;}
inline int min(int x,int y){return x<y?x:y;}
inline void ckmin(int &x,int y){x=x<y?x:y; return ;}
inline void ckmax(int &x,int y){x=x>y?x:y; return ;}
inline int gcd(int n,int m){return m?gcd(m,n%m):n;}
inline int lcm(int x,int y){return x/gcd(x,y)*y;}
inline void swap(int &x,int &y){int t=x; x=y; y=t; return ;}
namespace yspm{
inline int read(){
int res=0,f=1; char k;
while(!isdigit(k=getchar())) if(k=='-') f=-1;
while(isdigit(k)) res=res*10+k-'0',k=getchar();
return res*f;
}
char out[100];
inline void print(int x){
if(!x) return putchar('0'),putchar('\n'),void();
if(x<0) putchar('-'),x=-x;
int cnt=0; while(x) out[++cnt]=x%10,x/=10;
Down(i,cnt,1) putchar(out[i]+'0'); putchar('\n'); return ;
}
const int N=1e5+10,bl=510;
vector<int>f[N<<2];
int n,a[N],p,v;
inline void push_up(int x){
int rpos=0,lsz=f[x<<1].size(),rsz=f[x<<1|1].size(); f[x].clear();
for(reg int i=0;i<lsz;){
if(rpos==rsz||(f[x<<1][i]<f[x<<1|1][rpos]-i)) f[x].push_back(f[x<<1][i++]);
else f[x].push_back(f[x<<1|1][rpos++]-i);
} for(reg int j=rpos;j<rsz;++j) f[x].push_back(f[x<<1|1][j]-lsz);
return ;
}
inline void build(int p,int l,int r){
if(l==r) return f[p].resize(1),f[p][0]=a[l],void(); int mid=(l+r)>>1;
build(p<<1,l,mid); build(p<<1|1,mid+1,r);
if(r-l+1<=bl) push_up(p); return ;
}
inline void modify(int x,int l,int r){
if(l==r) return f[x][0]=a[l],void(); int mid=(l+r)>>1;
if(p<=mid) modify(x<<1,l,mid); else modify(x<<1|1,mid+1,r);
if(r-l+1<=bl) push_up(x); return ;
}
inline void query(int x,int l,int r){
if(l>=p&&r-l+1<=bl) return v+=upper_bound(f[x].begin(),f[x].end(),v)-f[x].begin(),void(); int mid=(l+r)>>1;
if(mid>=p) query(x<<1,l,mid); return query(x<<1|1,mid+1,r);
}
signed main(){
n=read(); rep(i,1,n) a[i]=i-read(); build(1,1,n);
int Q=read(); while(Q--){
if(read()==1){
int x=read(),y=read();
a[x]=x-y; p=x; modify(1,1,n);
}else{
p=read(); if(p==n) print(a[n]);
else v=a[p],++p,query(1,1,n),print(v);
}
} return 0;
}
}signed main(){return yspm::main();}
//Use The Time To Enrich This Selfclosing Youth |
#include <cstdio>
#include <vector>
#include <algorithm>
const int BLK=500;
const int MAXN=100005;
int as[MAXN];
int N;
std::vector<int> st[MAXN*4];
std::vector<int> st2[MAXN*4];
void build(int w,int L,int R,int a,int b){
if(a>=R||b<=L) return;
st[w].clear();
if(R-L==1){
st[w].push_back(as[L]);
}else{
int M=(L+R)/2;
build(w*2+1,L,M,a,b);
build(w*2+2,M,R,a,b);
if(R-L<=BLK){
int shift=0;
int i=0,j=0;
const auto& lchd=st[w*2+1];
const auto& rchd=st[w*2+2];
while(i<lchd.size()||j<rchd.size()){
if(j==rchd.size()||(i<lchd.size()&&lchd[i]+shift<rchd[j])){
st[w].push_back(lchd[i++]+shift);
}else{
st[w].push_back(rchd[j++]);
shift++;
}
}
}
}
st2[w].clear();
for(int i=0;i<st[w].size();i++){
st2[w].push_back(st[w][i]-i);
}
}
int query(int w,int L,int R,int a,int b,int v){
int v0=v;
if(a>=R||b<=L){
//do nothing
}else if(a<=L&&b>=R&&R-L<=BLK){
v+=(std::upper_bound(st2[w].begin(),st2[w].end(),v)-st2[w].begin());
}else{
int M=(L+R)/2;
v=query(w*2+1,L,M,a,b,v);
v=query(w*2+2,M,R,a,b,v);
}
return v;
}
int main(){
scanf("%d",&N);
for(int i=0;i<N;i++){
int B;
scanf("%d",&B);
as[i]=i-B;
}
build(0,0,N,0,N);
int Q;
scanf("%d",&Q);
while(Q--){
int T;
scanf("%d",&T);
if(T==1){
int I,X;
scanf("%d %d",&I,&X);
I--;
as[I]=I-X;
build(0,0,N,I,I+1);
}else{
int I;
scanf("%d",&I);
I--;
printf("%d\n",query(0,0,N,I+1,N,as[I])+1);
}
}
}
|
#include <cstdio>
#include <cmath>
#include <algorithm>
const int N=100005, B=805;
int n, p[N], bel[N], rk[N], id[B][B], tp, stk[B][B], top[B], len[B], q, blc=800;
int sum[N], lim, ln;
bool ok[B][N];
inline void add(int p, int v) { while(p<=ln) sum[p]+=v, p+=p&(-p); }
inline int ask(int v)
{
int p=0;
for(int i=lim; ~i; --i)
{
if((p|(1<<i))<=ln&&sum[p|(1<<i)]<v) p|=1<<i, v-=sum[p];
}
return p+1;
}
void build(int x)
{
int l=(x-1)*blc+1, r=std::min(n, x*blc), len=r-l+1;
int *stk=::stk[x], &top=::top[x];
top=r-l+1;
ln=r;
for(int i=r; i>=l; --i)
{
rk[i]=ask(p[i]);
add(rk[i], -1);
}
for(int i=l; i<=r; ++i) add(rk[i], 1);
for(int i=1; i<=len; ++i) id[x][i]=i+l-1;
std::sort(id[x]+1, id[x]+len+1, [] (int x, int y) { return rk[x]<rk[y]; });
for(int i=1; i<=len; ++i) stk[i]=rk[id[x][i]]-i;
}
int idl[N], idr[N], tpl, tpr;
void change(int x, int y, int v)
{
int l=(x-1)*blc+1, r=std::min(n, x*blc), len=r-l+1, *id=::id[x];
tpl=tpr=tp=0;
p[y]=v;
for(int i=y+1; i<=r; ++i) if(p[i]<=v) ++v;
if(v>rk[y])
{
for(int i=1, lst=0, pr=-2; i<=len; ++i)
{
int u=id[i];
if(u==y) continue;
int tt=rk[u];
if(pr!=rk[u]-1) lst=0;
if(u>y) idr[++tpr]=u, lst=(pr==rk[u]-1?lst+1:1);
else
{
if(rk[y]<rk[u]&&v>=rk[u]) rk[u]-=lst+1, idl[++tpl]=u;
else idr[++tpr]=u;
lst=0;
}
pr=tt;
}
}
else
{
for(int i=len, lst=0, pr=-2; i; --i)
{
int u=id[i];
if(u==y) continue;
int tt=rk[u];
if(pr!=rk[u]+1) lst=0;
if(u>y) idr[++tpr]=u, lst=(pr==rk[u]+1?lst+1:1);
else
{
if(rk[y]>rk[u]&&v<=rk[u]) rk[u]+=lst+1, idl[++tpl]=u;
else idr[++tpr]=u;
lst=0;
}
pr=tt;
}
std::reverse(idl+1, idl+tpl+1);
std::reverse(idr+1, idr+tpr+1);
}
int cl=1, cr=1;
while(cl<=tpl||cr<=tpr)
{
if(cl<=tpl&&(cr>tpr||rk[idl[cl]]<rk[idr[cr]]))
{
id[++tp]=idl[cl];
++cl;
}
else id[++tp]=idr[cr], ++cr;
}
int t=1;
rk[y]=v;
while(t<=tp&&rk[id[t]]<v) ++t;
for(int i=tp+1; i>t; --i) id[i]=id[i-1];
id[t]=y;
for(int i=1; i<=len; ++i) stk[x][i]=rk[id[i]]-i;
}
inline int query(int x)
{
int v=p[x];
for(int i=x+1; bel[i]==bel[x]; ++i) v+=v>=p[i];
for(int i=bel[x]+1; i<=bel[n]; ++i)
{
v+=std::lower_bound(stk[i]+1, stk[i]+top[i]+1, v)-stk[i]-1;
}
return v;
}
int main()
{
scanf("%d", &n);
for(int i=1; i<=n; ++i) scanf("%d", p+i), p[i]=i-p[i];
for(int i=1; i<=n; ++i) bel[i]=(i+blc-1)/blc;
while((1<<lim)<n) ++lim;
ln=n;
for(int i=1; i<=n; ++i) add(i, 1);
for(int i=1; i<=bel[n]; ++i) build(i);
scanf("%d", &q);
for(int i=1, op, x, y; i<=q; ++i)
{
scanf("%d%d", &op, &x);
if(op==1) scanf("%d", &y), y=x-y, change(bel[x], x, y);
else printf("%d\n", query(x));
}
return 0;
} |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <set>
#include <cstdlib>
#include <utility>
#include <cmath>
#include <queue>
#include <stack>
#include <cstring>
using namespace std;
#define ll long long
#ifndef ONLINE_JUDGE
#define debug(format, ...) fprintf(stderr, \
"%s:%d: " format "\n", __func__, __LINE__,##__VA_ARGS__)
#else
#define debug(format, ...)
#define NDEBUG
#endif
#define BLKSIZE 300
int n, q;
int b[100005];
int blkid[100005];
int blkbegin[100005];
// for block i, minimum start value required for j increases
int mincnt[400][405];
int f[100005];
int fen[300005];
#define lowbit(x) ((x)&(-(x)))
int rquery(int* arr, int v)
{
int ans = 0;
while (v) {
ans += arr[v]; v -= lowbit(v);
}
return ans;
}
void modify(int* arr, int loc, int val)
{
//printf("%d %lld\n", loc, val);
while (loc <= n) {
arr[loc] += val; loc += lowbit(loc);
}
}
void updateblock(int id)
{
int start = max(id * BLKSIZE, 1);
for (int i = start; blkid[i] == id; i++) {
int x = 0; int curv = 0;
for (int j = 16; j >= 0; j--) {
int nx = x + (1 << j);
if (nx <= n && curv + fen[nx] + nx <= b[i]) {
x = nx; curv += fen[nx];
}
}
f[i] = x + 1; if (f[i] <= n) modify(fen, f[i], 1);
}
vector<int> vals;
for (int i = start; blkid[i] == id; i++) {
vals.push_back(f[i]);
if (f[i] <= n) modify(fen, f[i], -1);
}
sort(vals.begin(), vals.end());
for (int i = 0; i < vals.size(); i++) {
mincnt[id][i+1] = vals[i];
}
for (int i = vals.size() + 1; i <= BLKSIZE; i++) {
mincnt[id][i] = 10000000;
}
}
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
blkid[0] = blkid[n + 1] = -1;
for (int i = 1; i <= n; i++) {
blkid[i] = i / BLKSIZE;
blkbegin[i] = (blkid[i-1] == blkid[i] ? blkbegin[i-1] : i);
}
for (int i = 0; i <= n / BLKSIZE; i++) {
updateblock(i);
}
scanf("%d", &q);
for (int qr = 1; qr <= q; qr++) {
int typ; scanf("%d", &typ);
if (typ == 1) {
int x, y; scanf("%d%d", &x, &y);
b[x] = y; updateblock(blkid[x]);
} else {
int x; scanf("%d", &x);
int cur = b[x] + 1; int i;
for (i = x + 1; blkid[i] == blkid[x]; i++) {
if (cur > b[i]) cur++;
}
if (i <= n) {
for (int j = blkid[i]; j <= n / BLKSIZE; j++) {
int l = 0; int r = BLKSIZE;
while (l < r) {
int mid = (l + r) / 2 + 1;
if (cur >= mincnt[j][mid]) {
l = mid;
} else {
r = mid - 1;
}
}
cur += l;
}
}
printf("%d\n", n + 1 - cur);
}
}
return 0;
}
|
// Awwawa! Dis cold yis ratten buy tEMMIE!
#include <bits/stdc++.h>
#define ll long long
#define maxn 100005 /*rem*/
#define mod 1000000007
#define db double
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define pi pair<int, int>
#define fi first
#define se second
template <typename T> bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T> bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
using namespace std;
ll ksm(ll a, ll b) {
if (!b)
return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1)
ns = ns * a % mod;
return ns;
}
int n, b[maxn], blk_size[maxn], rem[maxn];
int B, T, m;
int mark[maxn], f[maxn];
int query(int x) {
int pos = 0;
for (int c = 18; c >= 0; c--) {
if (pos + (1 << c) > m)
continue;
if (mark[pos + (1 << c)] != T) {
mark[pos + (1 << c)] = T;
f[pos + (1 << c)] = 0;
}
if ((1 << c) - f[pos + (1 << c)] <= x) {
x -= (1 << c) - f[pos + (1 << c)];
pos += (1 << c);
}
}
return pos + 1;
}
struct block {
int num[1010];
int pre[1010];
int cnt = 0;
void init() { cnt = 0; }
void build() {
sort(num + 1, num + cnt + 1);
for (int i = 1; i <= cnt; i++) {
pre[i] = pre[i - 1] + num[i] - num[i - 1] - 1;
}
}
int query(int x) {
int v = lower_bound(pre, pre + cnt + 1, x) - pre - 1;
return num[v] + x - pre[v];
}
void add(int x) {
num[++cnt] = x;
for (; x <= m; x += x & -x) {
if (mark[x] != T)
mark[x] = T, f[x] = 0;
f[x]++;
}
}
} c[1010];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
b[i] = i - b[i];
}
B = max(int(sqrt(n) / 2.2), 1);
T = 1;
int TB = (n - 1) / B;
m = n;
for (int i = n - 1; i >= 0; i--) {
blk_size[i] = m;
rem[i] = query(b[i]);
c[i / B].add(rem[i]);
if (i % B == 0) {
c[i / B].build();
m = i;
T++;
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int pos, num;
scanf("%d%d", &pos, &num);
--pos;
b[pos] = pos - num;
m = blk_size[pos];
int t = pos / B;
T++;
c[t].init();
for (int j = m - 1; j >= t * B; j--) {
rem[j] = query(b[j]);
c[t].add(rem[j]);
}
c[t].build();
} else {
int x;
scanf("%d", &x);
--x;
int y = rem[x];
for (int j = x / B + 1; j <= TB; j++) {
y = c[j].query(y);
}
printf("%d\n", y);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, SZ = 100;
int n, q, a[maxn], bel[maxn], bl[maxn], br[maxn];
vector<int> pos[maxn / SZ + 5];
namespace BIT {
int c[maxn];
void add(int p, int v) {
for (; p <= n; p += p & -p) c[p] += v;
}
// min p s.t. c_p >= s
int find(int s) {
int p = 1;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i <= n && c[p + i - 1] < s) p += i, s -= c[p - 1];
}
return p;
}
} // namespace BIT
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), a[i] = i - a[i];
}
for (int i = 1; i <= n; i++) {
br[bel[i] = (i - 1) / SZ + 1] = i;
if (!bl[bel[i]]) bl[bel[i]] = i;
}
auto rebuild = [&](int k) {
for (int i = bl[k]; i <= br[k]; i++) {
BIT::add(pos[k][i - bl[k]] = BIT::find(a[i]), 1);
}
for (int x : pos[k]) BIT::add(x, -1);
sort(pos[k].begin(), pos[k].end());
};
for (int i = 1; i <= n; i++) {
BIT::add(i, 1);
}
for (int i = 1; i <= bel[n]; i++) {
pos[i].resize(br[i] - bl[i] + 1), rebuild(i);
}
scanf("%d", &q);
while (q--) {
int op, i, x;
scanf("%d %d", &op, &i);
if (op == 1) {
scanf("%d", &x);
a[i] = i - x, rebuild(bel[i]);
} else {
int cur = a[i];
for (int j = i + 1; j <= br[bel[i]]; j++) {
cur += a[j] <= cur;
}
for (int j = bel[i] + 1; j <= bel[n]; j++) {
cur += upper_bound(pos[j].begin(), pos[j].end(), cur) - pos[j].begin();
}
printf("%d\n", cur);
}
}
return 0;
} |
// Author: wlzhouzhuan
#pragma GCC optimize(2,3,"Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fir first
#define sec second
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, l, r) for (int i = l; i >= r; i--)
#define mset(s, t) memset(s, t, sizeof(s))
#define mcpy(s, t) memcpy(s, t, sizeof(t))
#define poly vector<int>
#define SZ(x) (int(x.size()))
template<typename T1, typename T2> void ckmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> void ckmax(T1 &a, T2 b) { if (a < b) a = b; }
int read() {
int x = 0, f = 0; char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template<typename T> void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template<typename T> void print(T x, char let) {
print(x), putchar(let);
}
const int N = 100005;
const int inf = 1e9;
const int B = 200;
int L[N / B + 3], R[N / B + 3];
int a[N], be[N], n, q;
// f[i][j]: 通过第 i 块，使得数值 +=j 的读入范围 [f[i][j],f[i][j+1])
// f[i][j] 即为下界
int c[N], f[N / B + 3][B + 1];
#define ls (u << 1)
#define rs (u << 1 | 1)
int mn[N << 2], pos[N << 2], tag[N << 2];
inline void pushup(int u) {
if (mn[ls] <= mn[rs]) mn[u] = mn[ls], pos[u] = pos[ls];
else mn[u] = mn[rs], pos[u] = pos[rs];
}
inline void pushtag(int u, int dlt) {
mn[u] += dlt, tag[u] += dlt;
}
inline void pushdown(int u) {
if (tag[u]) {
pushtag(ls, tag[u]), pushtag(rs, tag[u]);
tag[u] = 0;
}
}
void build(int u, int l, int r) {
if (l == r) {
mn[u] = c[l], pos[u] = l;
return ;
}
int mid = l + r >> 1;
build(ls, l, mid), build(rs, mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
pushtag(u, -1);
return ;
}
pushdown(u);
int mid = l + r >> 1;
if (ql <= mid) update(ls, l, mid, ql, qr);
if (qr > mid) update(rs, mid + 1, r, ql, qr);
pushup(u);
}
void ban(int u, int l, int r, int pos) {
if (l == r) {
mn[u] = inf;
return ;
}
pushdown(u);
int mid = l + r >> 1;
if (pos <= mid) ban(ls, l, mid, pos);
else ban(rs, mid + 1, r, pos);
pushup(u);
}
void rebuild(int id, int l, int r) {
int len = r - l + 1;
for (int j = l; j <= r; j++) c[j - l + 1] = a[j];
memset(mn, 0, 16 * len);
memset(pos, 0, 16 * len);
memset(tag, 0, 16 * len);
build(1, 1, len);
for (int j = 1; j <= len; j++) {
f[id][j] = max(f[id][j - 1], mn[1]);
int who = pos[1];
if (who != len) update(1, 1, len, who + 1, len);
ban(1, 1, len, who);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = i - read(), be[i] = (i - 1) / B + 1;
for (int l = 1, r = B, id = 1; l <= n; l += B, r += B, id++) {
r = min(r, n), L[id] = l, R[id] = r;
rebuild(id, l, r);
}
q = read();
while (q--) {
int opt = read(), x = read();
if (opt == 1) {
int t = read();
a[x] = x - t;
rebuild(be[x], L[be[x]], R[be[x]]);
} else {
int now = a[x];
for (int i = x + 1; i <= R[be[x]]; i++) {
if (now >= a[i]) ++now;
}
// printf("after now = %d\n", now);
for (int i = be[x] + 1; i <= be[n]; i++) {
int pos = upper_bound(f[i] + 1, f[i] + (R[i] - L[i] + 1) + 1, now) - f[i];
now += pos - 1;
// printf("after block (%d, %d), now = %d\n", L[i], R[i], now);
// for (int j = 1; j <= R[i] - L[i] + 1; j++) printf("f[%d][%d] = %d\n", i, j, f[i][j]);
// puts("-----");
}
print(now, '\n');
// system("pause");
}
}
return 0;
} |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <set>
#include <cstdlib>
#include <utility>
#include <cmath>
#include <queue>
#include <stack>
#include <cstring>
using namespace std;
#define ll long long
#ifndef ONLINE_JUDGE
#define debug(format, ...) fprintf(stderr, \
"%s:%d: " format "\n", __func__, __LINE__,##__VA_ARGS__)
#else
#define debug(format, ...)
#define NDEBUG
#endif
#define BLKSIZE 200
int n, q;
int b[100005];
int blkid[100005];
int blkbegin[100005];
// for block i, minimum start value required for j increases
int mincnt[1000][1005];
int f[100005];
int fen[300005];
#define lowbit(x) ((x)&(-(x)))
int rquery(int* arr, int v)
{
int ans = 0;
while (v) {
ans += arr[v]; v -= lowbit(v);
}
return ans;
}
void modify(int* arr, int loc, int val)
{
//printf("%d %lld\n", loc, val);
while (loc <= n) {
arr[loc] += val; loc += lowbit(loc);
}
}
void updateblock(int id)
{
int start = max(id * BLKSIZE, 1);
for (int i = start; blkid[i] == id; i++) {
int x = 0; int curv = 0;
for (int j = 16; j >= 0; j--) {
int nx = x + (1 << j);
if (nx <= n && curv + fen[nx] + nx <= b[i]) {
x = nx; curv += fen[nx];
}
}
f[i] = x + 1; if (f[i] <= n) modify(fen, f[i], 1);
}
vector<int> vals;
for (int i = start; blkid[i] == id; i++) {
vals.push_back(f[i]);
if (f[i] <= n) modify(fen, f[i], -1);
}
sort(vals.begin(), vals.end());
for (int i = 0; i < vals.size(); i++) {
mincnt[id][i+1] = vals[i];
}
for (int i = vals.size() + 1; i <= BLKSIZE; i++) {
mincnt[id][i] = 10000000;
}
}
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", b + i);
blkid[0] = blkid[n + 1] = -1;
for (int i = 1; i <= n; i++) {
blkid[i] = i / BLKSIZE;
blkbegin[i] = (blkid[i-1] == blkid[i] ? blkbegin[i-1] : i);
}
for (int i = 0; i <= n / BLKSIZE; i++) {
updateblock(i);
}
scanf("%d", &q);
for (int qr = 1; qr <= q; qr++) {
int typ; scanf("%d", &typ);
if (typ == 1) {
int x, y; scanf("%d%d", &x, &y);
b[x] = y; updateblock(blkid[x]);
} else {
int x; scanf("%d", &x);
int cur = b[x] + 1; int i;
for (i = x + 1; blkid[i] == blkid[x]; i++) {
if (cur > b[i]) cur++;
}
if (i <= n) {
for (int j = blkid[i]; j <= n / BLKSIZE; j++) {
int l = 0; int r = BLKSIZE;
while (l < r) {
int mid = (l + r) / 2 + 1;
if (cur >= mincnt[j][mid]) {
l = mid;
} else {
r = mid - 1;
}
}
cur += l;
}
}
printf("%d\n", n + 1 - cur);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int inf = 1e9;
const ll inf64 = 1e18;
struct Query {
int t = 0;
int i = 0;
int x = 0;
};
vector<int> slow(int n, vector<int> b, int q, vector<Query> queries) {
vector<int> res;
for (auto query : queries) {
if (query.t == 1) {
b[query.i] = query.x;
} else {
set<int> Q;
for (int x = 1; x <= n; x++)
Q.insert(x);
int last = -1;
for (int i = n; i >= query.i; i--) {
int lt = i - 1 - b[i];
auto it = Q.begin();
advance(it, lt);
last = *it;
Q.erase(it);
}
res.push_back(last);
}
}
return res;
}
struct Ord {
int n = 0;
set<int> q;
Ord() = default;
Ord(int nn) {
n = nn;
}
void insert(int x) {
q.insert(x);
}
int query(int x) {
int pos = 0;
for (auto y : q) {
if (y == x)
return pos + 1;
pos++;
}
return -1;
}
};
struct Processor {
int n = 0; // [0, n)
vector<int> a;
Processor() = default;
Processor(int nn) {
n = nn;
a.assign(n, 0);
}
void increase(int i, int x) {
for (int cur = i; cur < n; cur |= (cur + 1))
a[cur] += x;
}
int descent(int lb) {
int pos = 0;
for (int pw = 1 << 19; pw > 0; pw >>= 1) {
if (pos + pw <= n && a[pos + pw - 1] < lb) {
lb -= a[pos + pw - 1];
pos += pw;
}
}
return pos;
}
};
vector<int> fast(int n, vector<int> b, int q, vector<Query> queries) {
b.erase(b.begin());
for (int i = 0; i < n; i++) {
b[i] = i - b[i];
}
// int k = 0; while (k * k <= n) k++; k++;
int k = 300;
Processor proc(n);
vector<vector<int>> vals((n - 1) / k + 1);
auto build_block = [&](int j) {
int l = j * k;
int r = min(n, l + k);
if (vals[j].empty())
vals[j].resize(r - l);
for (int i = l; i < r; i++) {
int sep = proc.descent(b[i]);
proc.increase(sep, +1);
vals[j][i - l] = sep;
}
sort(vals[j].begin(), vals[j].end());
for (auto x : vals[j])
proc.increase(x, -1);
};
{
vector<int> Q;
for (int x = 1; x < n; x++)
proc.increase(x, +1);
for (int j = 0; j < (int) vals.size(); j++) {
build_block(j);
}
}
vector<int> res;
for (auto query : queries) {
query.i--;
if (query.t == 1) {
query.x = query.i - query.x;
b[query.i] = query.x;
}
int bid = query.i / k;
if (query.t == 1) {
build_block(bid);
} else {
int cur = b[query.i];
for (int i = query.i + 1; i / k == bid && i < n; i++) {
if (cur >= b[i])
cur++;
}
for (int j = bid + 1; j < (int) vals.size(); j++) {
// val[x] = int(x > 0) + #{elem in vals[j]: elem <= x}
// val[x] >= cur
// x -> min
cur += int(upper_bound(vals[j].begin(), vals[j].end(), cur) - vals[j].begin());
}
res.push_back(cur + 1);
}
}
return res;
}
void test() {
mt19937 rnd(42);
const int MAXN = 100;
const int MAXQ = 100;
while (1) {
int n = rnd() % MAXN + 1;
vector<int> b(n + 1);
for (int i = 1; i <= n; i++)
b[i] = rnd() % i;
int q = rnd() % MAXQ + 1;
vector<Query> queries(q);
for (auto& query : queries) {
query.t = rnd() % 2 + 1;
query.i = rnd() % n + 1;
if (query.t == 1)
query.x = rnd() % query.i;
}
cout << n << "\n";
for (int i = 1; i <= n; i++)
cout << b[i] << " ";
cout << "\n";
cout << q << "\n";
for (auto query : queries) {
cout << query.t << " " << query.i << " ";
if (query.t == 1)
cout << query.x << " ";
cout << "\n";
}
cout.flush();
vector<int> fs = fast(n, b, q, queries);
vector<int> sl = slow(n, b, q, queries);
if (fs == sl) {
cout << "OK( "; for (auto x : fs) cout << x << " "; cout << ")" << endl;
} else {
cout << "WA\n";
cout << "exp = "; for (auto x : sl) cout << x << " "; cout << "\n";
cout << "fnd = "; for (auto x : fs) cout << x << " "; cout << "\n";
break;
}
}
}
void work() {
int n;
cin >> n;
vector<int> b(n + 1);
for (int i = 1; i <= n; i++)
cin >> b[i];
int q;
cin >> q;
vector<Query> queries(q);
for (auto& query : queries) {
cin >> query.t >> query.i;
if (query.t == 1)
cin >> query.x;
}
vector<int> res = fast(n, b, q, queries);
for (auto x : res)
cout << x << "\n";
}
int main() {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
work();
// test();
return 0;
} |
#include<bits/stdc++.h>
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define len(x) (int)(x).size()
typedef long long ll;
typedef long double ld;
using namespace std;
const bool debug = 0;
const int N = (int)1e5 + 10;
const int inf = 1e9;
const int buben = 400;
mt19937 rng(199999973);
vector < pair<int,int> > indablock[N/buben+1];
int perm[N], n;
pair<int,int> memory[4*buben][buben];
int PNT[4*buben];
void OG(int v, vector<int>&perm, int l , int r){
if(l == r){
PNT[v]=0;
memory[v][PNT[v]++] = {0,0};
memory[v][PNT[v]++] = {perm[l] , 1};
memory[v][PNT[v]++] = {N, 0};
return;
}
int mid = (l + r) >> 1;
OG(v*2+1, perm, l , mid);
OG(v*2, perm, mid+1 , r);
PNT[v]=0;
int lst = 0;
int LST = 0;
for(int x = 0; x < PNT[2*v+1] - 1; ++x){
/// cur is
int L = memory[2*v+1][x].fi + memory[2*v+1][x].se;
int R = min(N-5,memory[2*v+1][x+1].fi-1 + memory[2*v+1][x].se);
while(lst+1 < PNT[2*v] && memory[2*v][lst+1].fi <= L)
++lst;
if(lst == PNT[2*v]-1){
memory[v][PNT[v]++]= {memory[2*v+1][x].fi , memory[2*v+1][x].se};
}else{
while(lst < PNT[2*v]-1){
assert(memory[2*v][lst].fi <= L);
int r = min(R , memory[2*v][lst+1].fi-1);
/// so for them
memory[v][PNT[v]++] = {L-memory[2*v+1][x].se, memory[2*v+1][x].se+memory[2*v][lst].se};
L = r + 1;
if(r == R)
break;
lst++;
}
}
}
// assert(len(C) <= 2*buben);
memory[v][PNT[v]++] = {N, 0};
}
void additupbankroll(int id , vector<int>perm){
OG(1, perm, 0 , len(perm)-1);
indablock[id].clear();
for(int x = 0 ; x < PNT[1]; ++x)
indablock[id].pb(memory[1][x]);
}
int pass_through(int id, int x){
int ind = lower_bound(all(indablock[id]), make_pair(x+1,-1)) - indablock[id].begin();
ind--;
return indablock[id][ind].se;
}
void flexindablock(int id){
/// so
int L = id * buben, R = min(n-1, (id+1)*buben-1);
vector<int>cur;
for(int x = L;x <= R; ++x){
cur.pb(x+1-perm[x]);
}
additupbankroll(id , cur);
}
signed main(){
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
if(debug)
n = 1e5;
else
cin >> n;
for(int i = 0 ; i < n; ++i){
if(debug)
perm[i] = rng()%(i+1);
else
cin >> perm[i];
}
int q;
if(debug)
q = 1e5;
else
cin >> q;
/// so the id is
for(int i =0 ; i <= (n-1)/buben; ++i){
flexindablock(i);
}
int done = 0;
while(q--){
// cerr << done << '\n';
int t;
if(debug){
t = rng() % 2 + 1;
}else
cin >> t;
if(t == 1){
int i , x;
if(debug){
i = rng() % n;
i++;
x = rng() % i;
}else
cin >> i >> x;
// assert(i >= 1 && i <= n);
// assert(x >= 0 && x < i);
--i;
perm[i] = x;
flexindablock(i / buben);
}else{
int i;
if(debug)
i = rng() % n + 1;
else
cin >> i;
// assert(i >= 1 && i <= n);
--i;
/// so firstly our pos is
int x = i + 1 - perm[i];
i++;
while(i < n){
if(i % buben == 0 && i + buben - 1 < n){
x += pass_through(i / buben , x);
i += buben;
continue;
}
int cur = i + 1 - perm[i];
if(x >= cur)
x++;
i++;
}
cout << x << '\n';
}
// done++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2,fma,tune=native")
#define ll long long
#define int ll
#define ull unsigned ll
#define ld long double
#define rep(a) rep1(i,a)
#define rep1(i,a) rep2(i,0,a)
#define rep2(i,b,a) for(int i=(b); i<((int)(a)); i++)
#define rep3(i,b,a) for(int i=(b); i>=((int)(a)); i--)
#define chkmin(a,b) (a=min(a,b))
#define chkmax(a,b) (a=max(a,b))
#define all(a) a.begin(),a.end()
#define pii pair<int,int>
#define pb push_back
//#define inf 1010000000
#define inf 4000000000000000000
#define eps 1e-9
#define sz(a) ((int)a.size())
#define pow2(x) (1ll<<(x))
#define ceiling(a,b) (((a)+(b)-1)/(b))
#define print0(a) cout << (a) << ' '
#define ykh mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#ifdef i_am_noob
#define bug(...) cerr << "#" << __LINE__ << ' ' << #__VA_ARGS__ << "- ", _do(__VA_ARGS__)
template<typename T> void _do(vector<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(unordered_set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(T && x) {cerr << x << endl;}
template<typename T, typename ...S> void _do(T && x, S&&...y) {cerr << x << ", "; _do(y...);}
#else
#define bug(...) 826
#endif
template<typename T> void print(T && x) {cout << x << "\n";}
template<typename T, typename... S> void print(T && x, S&&... y) {cout << x << ' ';print(y...);}
const int Mod=1000000007,Mod2=998244353;
const int MOD=Mod2;
const int maxn=100005;
//i_am_noob
//#define wiwihorz
const int K=115;
int n,a[maxn];
vector<int> vec[maxn/K+5],vec2[maxn/K+5];
template<int N>
struct BIT{
int val[N];
void modify(int x, int y){for(int i=++x; i<N; i+=i&-i) val[i]+=y;}
int query(int x, int y){
int ret=0;
for(int i=++y; i; i-=i&-i) ret+=val[i];
for(int i=x; i; i-=i&-i) ret-=val[i];
return ret;
}
};
BIT<maxn> bit;
void build(int x){
vec[x].clear(),vec2[x].clear();
rep(K) if(x*K+i<n){
int cur=0,curval=0;
int tar=a[x*K+i];
//bug(tar);
rep3(k,16,0){
int ncur=cur+pow2(k);
if(ncur<n&&ncur-(curval+bit.val[ncur])<=tar) cur=ncur,curval+=bit.val[ncur];
}
//bug(cur);
vec[x].pb(cur);
vec2[x].pb(cur);
bit.modify(cur,1);
}
sort(all(vec[x]));
for(auto j: vec[x]) bit.modify(j,-1);
//bug(vec[x]),bug(vec2[x]);
}
void orzck(){
ld start=clock();
cin >> n;
rep(n) cin >> a[n-1-i];
rep(n) a[i]=(n-1-i)-a[i];
//rep(n) bug(a[i]);
for(int i=0; i<n; i+=K){
build(i/K);
}
bug("de");
int q;
cin >> q;
while(q--){
int op;
cin >> op;
if(op==1){
int x,y;
cin >> x >> y;
y=x-1-y;
x=n-x;
a[x]=y;
build(x/K);
}
else{
int x;
cin >> x;
x=n-x;
int t=x/K,cur=vec2[x/K][x%K];
rep3(i,t-1,0){
if(vec[i][0]>cur) continue;
int l=0,r=sz(vec[i])-1;
while(l<r){
int mid=l+r+1>>1;
if(vec[i][mid]-mid<=cur) l=mid;
else r=mid-1;
}
cur+=l+1;
}
print(cur+1);
}
}
bug((clock()-start)/CLOCKS_PER_SEC);
}
signed main(){
ios_base::sync_with_stdio(0),cin.tie(0);
#ifdef i_am_noob
freopen("input1.txt","r",stdin);
freopen("output1.txt","w",stdout);
freopen("output2.txt","w",stderr);
#endif
cout << fixed << setprecision(15);
int t;
#ifdef wiwihorz
cin >> t;
#else
t=1;
#endif
while(t--) orzck();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
#define F first
#define S second
const int MOD = 1e9 + 7;//XXX
const int C = 26;//XXX
void add(int &x, int y){
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x){
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b){
int ret = 1;
while (b){
if (b & 1)
ret = 1ll*ret*a%MOD;
b >>= 1;
a = 1ll*a*a%MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
const int SQ = 100;
int n, a[MAXN];
int weed[MAXN<<2];
vector<int> vec[(MAXN + SQ - 1) / SQ]; // +1 for each of these you're >= than
void plant(int v, int b, int e) {
if(e-b == 1) {
weed[v] = b != 0;
return;
}
int m = (b + e) >> 1;
plant(v<<1, b, m);
plant(v<<1^1, m, e);
weed[v] = weed[v<<1] + weed[v<<1^1];
}
void water(int i, int x) {
int v = 1, b = 0, e = n;
while(b < e) {
weed[v] += x;
if(e-b == 1)
break;
int m = (b + e) >> 1;
if(i < m) {
e = m;
v = v<<1;
} else {
b = m;
v = v<<1^1;
}
}
}
int descend(int s) { // first >= s
int v = 1, b = 0, e = n;
while(b < e) {
if(e-b == 1) {
return weed[v] < s ? e : b;
}
int m = (b + e) >> 1;
if(weed[v<<1] < s) {
s -= weed[v<<1];
v = v<<1^1;
b = m;
} else {
v = v<<1;
e = m;
}
}
return -1;
}
void build(int id) {
vec[id].clear();
int l = id * SQ, r = min(n, l + SQ);
for(int i = l; i < r; i++) {
int j = descend(a[i]);
vec[id].push_back(j);
water(j, 1);
}
for(int j : vec[id])
water(j, -1);
sort(vec[id].begin(), vec[id].end());
}
void qry() {
int i; cin >> i; i--;
int ans = a[i];
for(i++; i < n && i % SQ != 0; i++)
if(a[i] <= ans)
++ans;
for(; i < n; i += SQ) {
ans += upper_bound(vec[i / SQ].begin(), vec[i / SQ].end(), ans) - vec[i / SQ].begin();
}
cout << ans+1 << "\n";
}
void solve() {
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
a[i] = i - a[i];
}
plant(1, 0, n);
for(int l = 0; l < n; l += SQ) {
build(l / SQ);
}
int q; cin >> q;
while(q--) {
int qt; cin >> qt;
if(qt == 1) {
int i, x; cin >> i >> x; --i; x = i - x;
a[i] = x;
build(i / SQ);
} else {
qry();
}
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cout << fixed << setprecision(6);
int te = 1;
//cin >> te;
for (int w = 1; w <= te; w++){
//cout << "Case #" << w << ": ";
solve();
}
return 0;
}
|
#include <iostream>
using namespace std;
const int n = 100352;
const int lgbt = 9;
const int b = 1 << lgbt;
int indexes[lgbt + 1][n];
int values[lgbt + 1][n];
int set[n];
void merge(int k, int l) {
int end = k + (1 << l);
int mid = k + (1 << (l - 1));
int x = mid;
int y = k;
for (int z = k; z < end; z++) {
if (y < mid && (x == end || values[l - 1][y] + (x - mid) < values[l - 1][x])) {
indexes[l][z] = indexes[l - 1][y];
values[l][z] = values[l - 1][y] + (x - mid);
y++;
} else {
indexes[l][z] = indexes[l - 1][x];
values[l][z] = values[l - 1][x];
x++;
}
}
}
void assign(int k) {
for (int x = k; x < k + b; x++) {
set[indexes[lgbt][x]] = values[lgbt][x];
}
}
int find(int k, int x) {
int upper = b;
int lower = 0;
while (upper > lower) {
int mid = (upper + lower) / 2;
if (x + mid < values[lgbt][k + mid]) {
upper = mid;
} else {
lower = mid + 1;
}
}
return x + upper;
}
void update(int k) {
for (int l = 1; l <= lgbt; l++) {
k = (k >> l) << l;
merge(k, l);
}
assign(k);
}
int calc(int k) {
int x = set[k];
k = ((k >> lgbt) << lgbt) + b;
for (; k < n; k += b) {
x = find(k, x);
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int nActual;
cin >> nActual;
for (int x = 0; x < n; x++) {
indexes[0][x] = x;
if (x < nActual) {
int a;
cin >> a;
values[0][x] = x - a;
} else {
values[0][x] = x;
}
}
for (int l = 1; l <= lgbt; l++) {
for (int k = 0; k < n; k += 1 << l) {
merge(k, l);
}
}
for (int k = 0; k < n; k += b) {
assign(k);
}
int q;
for (cin >> q; q; q--) {
int type, k;
cin >> type >> k;
k--;
if (type == 1) {
int a;
cin >> a;
values[0][k] = k - a;
update(k);
} else {
cout << calc(k) + 1 << ' ';
}
}
cout << endl;
} |
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <cassert>
#include <unistd.h>
using namespace std;
#define LOG(f...) fprintf(stderr, f)
#define all(cont) begin(cont), end(cont)
using ll = long long;
template<class T> void read(T &x) {
char ch; x = 0;
int f = 1;
while (isspace(ch = getchar()));
if (ch == '-') ch = getchar(), f = -1;
do x = x * 10 + (ch - '0'); while(isdigit(ch = getchar()));
x *= f;
}
template<class T, class ...A> void read(T &x, A&... args) { read(x); read(args...); }
const int B = 1024;
const int N = 100000;
struct pt {
int x, y;
pt() = default;
pt(int _x, int _y) : x(_x), y(_y) {}
};
int a[N];
vector<pt> t[N / B + 2][B * 2 + 2];
vector<pt> composite(const vector<pt> &l, const vector<pt> &r, vector<pt> &res) {
res.clear();
auto itl = begin(l), itr = begin(r), tl = end(l), tr = end(r);
while (itl != tl && itr != tr) {
if (itl->y == itr->x)
res.emplace_back(itl->x, itr->y), ++itl, ++itr;
else if (itl->y < itr->x) {
if (itr != begin(r)) res.emplace_back(itl->x, prev(itr)->y + itl->y - prev(itr)->x);
++itl;
}
else {
if (itl != begin(l)) {
int pos = itr->x - prev(itl)->y + prev(itl)->x;
if (pos < itl->x)
res.emplace_back(itr->x - prev(itl)->y + prev(itl)->x, itr->y);
}
++itr;
}
}
for (; itl != tl; ++itl)
res.emplace_back(itl->x, r.back().y + itl->y - r.back().x);
for (; itr != tr; ++itr)
res.emplace_back(l.back().x + itr->x - l.back().y, itr->y);
return res;
}
int eval(const vector<pt> &a, int x) {
auto it = prev(partition_point(all(a), [&](const pt &a) { return a.x <= x; }));
return it->y + (x - it->x);
}
void build(vector<pt> *t, int x, int l, int r) {
if (l == r) {
if (a[l] == 0) t[x] = {pt(0, 1)};
else t[x] = {pt(0, 0), pt(a[l], a[l] + 1)};
return;
}
int mid = (l + r) >> 1;
build(t, x << 1, l, mid);
build(t, x << 1 | 1, mid + 1, r);
t[x].reserve(t[x << 1].size() + t[x << 1 | 1].size());
composite(t[x << 1], t[x << 1 | 1], t[x]);
}
void update(vector<pt> *t, int x, int l, int r, int pos) {
if (l == r) {
if (a[l] == 0) t[x] = {pt(0, 1)};
else t[x] = {pt(0, 0), pt(a[l], a[l] + 1)};
return;
}
int mid = (l + r) >> 1;
pos <= mid ? update(t, x << 1, l, mid, pos) : update(t, x << 1 | 1, mid + 1, r, pos);
composite(t[x << 1], t[x << 1 | 1], t[x]);
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n, qc;
read(n);
for (int i = 0; i < n; ++i)
read(a[i]), a[i] = i - a[i];
int bc = (n - 1) / B + 1;
for (int b = 0; b < bc; ++b) {
int bl = b * B, br = min(n, (b + 1) * B);
build(t[b], 1, bl, br - 1);
}
read(qc);
while (qc--) {
int opt, p;
read(opt, p); --p;
int b = p / B, bl = b * B, br = min(n, (b + 1) * B);
if (opt == 1) {
read(a[p]);
a[p] = p - a[p];
update(t[p / B], 1, bl, br - 1, p);
}
else {
int res = a[p];
for (int i = p + 1; i < br; ++i)
res += a[i] <= res;
for (int i = b + 1; i < bc; ++i)
res = eval(t[i][1], res);
printf("%d\n", res + 1);
}
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int N=100005,B=50;
int n,m,Q;
int a[N],b[N];
struct BIT
{
int C[N];
int lowbit(int x)
{
return x&-x;
}
void add(int x,int y)
{
for(int i=x;i<=n;i+=lowbit(i))
C[i]+=y;
return;
}
int getsum(int x)
{
int res=0;
for(int i=x;i>0;i-=lowbit(i))
res+=C[i];
return res;
}
}T;
int bel[N];
struct Block
{
int l,r;
int p[B+5];
}block[N/B+5];
void update(int k)
{
vector<int>pos;
for(int i=block[k].l;i<=block[k].r;i++)
{
int l=1,r=n,p=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(mid+T.getsum(mid)>=a[i]) p=mid,r=mid-1;
else l=mid+1;
}
pos.emplace_back(p);
T.add(p,1);
}
for(int v=0;v<=block[k].r-block[k].l+1;v++)
{
int l=v>0?block[k].p[v-1]:0,r=n,ans=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(T.getsum(mid)<=v) ans=mid,l=mid+1;
else r=mid-1;
}
block[k].p[v]=ans;
}
for(int p:pos)
T.add(p,-1);
return;
}
int query(int x)
{
int ans=a[x];
for(int i=x+1;i<=block[bel[x]].r;i++)
if(ans>=a[i]) ans++;
for(int i=bel[x]+1;i<=m;i++)
{
int v=lower_bound(block[i].p,block[i].p+block[i].r-block[i].l+1+1,ans)-block[i].p;
ans+=v;
}
return ans;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&b[i]);
for(int i=1;i<=n;i++)
a[i]=i-b[i];
for(int i=1;i<=n;i++)
bel[i]=(i-1)/B+1;
m=(n-1)/B+1;
for(int i=1;i<=m;i++)
block[i].l=(i-1)*B+1,block[i].r=min(i*B,n);
for(int k=1;k<=m;k++)
{
vector<int>pos;
for(int i=block[k].l;i<=block[k].r;i++)
{
int l=1,r=n,p=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(mid+T.getsum(mid)>=a[i]) p=mid,r=mid-1;
else l=mid+1;
}
pos.emplace_back(p);
T.add(p,1);
}
for(int v=0;v<=block[k].r-block[k].l+1;v++)
{
int l=v>0?block[k].p[v-1]:0,r=n,ans=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(T.getsum(mid)<=v) ans=mid,l=mid+1;
else r=mid-1;
}
block[k].p[v]=ans;
}
for(int p:pos)
T.add(p,-1);
}
scanf("%d",&Q);
while(Q--)
{
int op,i;
scanf("%d",&op);
if(op==1)
{
int x;
scanf("%d%d",&i,&x);
b[i]=x,a[i]=i-b[i];
update(bel[i]);
}
else if(op==2)
{
scanf("%d",&i);
printf("%d\n",query(i));
}
}
return 0;
} |
#include<bits/stdc++.h>
#define lowbit(x) ((x)&(-(x)))
template <typename _Tp>void read(_Tp &x){
char ch(getchar());bool f(false);while(!isdigit(ch))f|=ch==45,ch=getchar();
x=ch&15,ch=getchar();while(isdigit(ch))x=x*10+(ch&15),ch=getchar();
if(f)x=-x;
}
template <typename _Tp,typename... Args>void read(_Tp &t,Args &...args){read(t);read(args...);}
const int N=100005,S=150;
int a[N],n,c[N];
void add(int x,int C){for(++x;x<=n;x+=lowbit(x))c[x]+=C;}
int find(int lim){
int p=0,s=0;
for(int i=17;i>=0;--i)if(p+(1<<i)<=n&&s+c[p+(1<<i)]<lim)p+=1<<i,s+=c[p];
return p;
}
int ask(int x){
++x;int ans=0;for(;x;x-=lowbit(x))ans+=c[x];
return ans;
}
struct BLOCK{
int a[S+5],x[S+5],y[S+5],len,pos;
void rebuild(){
x[0]=0,pos=1;for(int i=0;i<len;++i)add(x[pos++]=find(a[i]),1);
std::sort(x,x+pos);for(int i=0;i<pos;++i)y[i]=ask(x[i])-x[i];
for(int i=1;i<pos;++i)add(x[i],-1);
}
inline void trans(int &p){p+=y[std::upper_bound(x,x+pos,p)-x-1];}
}b[N/S+5];
int main(){
read(n);int mb=(n-1)/S;
for(int i=0;i<n;++i)read(a[i]);
for(int i=1;i<=n;++i)add(i,1);
for(int l=0,r=S-1,cur=0;l<n;l+=S,r+=S){
r=std::min(r,n-1),b[cur].len=r-l+1;
for(int i=l;i<=r;++i)b[cur].a[i-l]=a[i];
b[cur++].rebuild();
}
int q,opt,x,y;read(q);
while(q--){
read(opt,x),--x;
if(opt==1)read(y),b[x/S].a[x%S]=y,b[x/S].rebuild(),a[x]=y;
else{
int lim=a[x];++x;
for(int i=x,ed=std::min(n,(x/S+1)*S);i<ed;++i)if(a[i]<=lim)++lim;
for(int i=x/S+1;i<=mb;++i)b[i].trans(lim);
printf("%d\n",n-lim);
}
}
return 0;
} |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int MAXN=100100;
int n;
int b[MAXN],l[MAXN],r[MAXN],pos[MAXN],tr[MAXN];
vector<int> v[MAXN];
void add(int x,int d)
{
while(x<=n)
{
tr[x]+=d;
x+=x&(-x);
}
}
int find(int x)
{
int ret=0;
for(int i=17;i>=0;i--)
{
if(ret+(1<<i)<n&&tr[ret+(1<<i)]+(1<<i)<x)
{
ret+=1<<i;
x-=tr[ret]+(1<<i);
}
}
return ret+1;
}
void build(int x)
{
v[x].clear();
for(int i=l[x];i<=r[x];i++)
{
int p=find(b[i]+1)-1;
v[x].push_back(p);
add(p+1,1);
}
for(int i=0;i<v[x].size();i++)
add(v[x][i]+1,-1);
sort(v[x].begin(),v[x].end());
}
int main()
{
int i,j,len,blocks,q,op,x,y,ans;
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&b[i]);
len=min(n,200);
blocks=n/len;
if(n%len)
blocks++;
for(i=1;i<=blocks;i++)
{
l[i]=(i-1)*len+1;
r[i]=min(n,i*len);
for(j=l[i];j<=r[i];j++)
pos[j]=i;
}
for(i=1;i<=blocks;i++)
build(i);
scanf("%d",&q);
while(q--)
{
scanf("%d",&op);
if(op==1)
{
scanf("%d%d",&x,&y);
b[x]=y;
build(pos[x]);
}
else
{
scanf("%d",&x);
ans=b[x];
for(i=x+1;i<=r[pos[x]];i++)
{
if(ans>=b[i])
ans++;
}
for(i=pos[x]+1;i<=blocks;i++)
ans+=upper_bound(v[i].begin(),v[i].end(),ans)-v[i].begin();
printf("%d\n",n-ans);
}
}
}
|
#include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) cout<<i<<" ";puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
const int N = 1e5+10, M = 1010;
int n,q,B,a[N],id[N],cnt[M];
int b[M],tag[M<<2];
pa mn[M<<2];
inline void Build(int u,int l,int r){
tag[u]=0;
if (l==r) return mn[u]=mp(b[l],l),void(0);
int mid=l+r>>1;
Build(u<<1,l,mid),Build(u<<1^1,mid+1,r);
mn[u]=min(mn[u<<1],mn[u<<1^1]);
}
inline void update(int u,int l,int r,int ql){
if (l>ql) return tag[u]--,mn[u].fi--,void(0);
if (l==r) return mn[u]=mp(1e9,l),void(0);
int mid=l+r>>1;
update(u<<1^1,mid+1,r,ql);
if (ql<=mid) update(u<<1,l,mid,ql);
mn[u]=min(mn[u<<1],mn[u<<1^1]),mn[u].fi+=tag[u];
}
int v[M][M];
inline void ReBuild(int id){
int l=(id-1)*B+1,r=min(id*B,n),cnt=0;
For(i,l,r) b[++cnt]=a[i];
Build(1,1,cnt);
For(i,1,cnt){
int tmp=mn[1].fi;
v[id][i]=max(tmp,v[id][i-1]),update(1,1,cnt,mn[1].se);
}
}
inline int Query(int x){
int y=a[x];
For(i,x+1,min(id[x]*B,n)) y+=(y>=a[i]);
For(i,id[x]+1,id[n]){
int tmp=upper_bound(v[i]+1,v[i]+cnt[i]+1,y)-v[i]-1;
y+=tmp;
}
return n-y;
}
int main(){
n=read(),B=150;
For(i,1,n) a[i]=read(),id[i]=(i-1)/B+1,cnt[id[i]]++;
For(i,1,id[n]) ReBuild(i);
q=read();
while (q--){
int op=read(),x=read();
if (op==1){
int y=read();
a[x]=y,ReBuild(id[x]);
} else {
printf("%d\n",Query(x));
}
}
} |
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<complex>
#include<set>
#include<queue>
#include<unordered_map>
#include<bitset>
#include<complex>
#include<math.h>
#include<cmath>
#include<iomanip>
#include<stack>
using ll = long long;
using ld = long double;
#define int ll
//#define double ld
#define all(a) a.begin(), a.end()
const ll inf = 1e9 + 7;
const ll INF = 1e17 + 7;
const ll mod = 998244353;
const ld eps = 1e-7;
using namespace std;
using pii = pair<int, int>;
template<typename T>
using vec = vector<T>;
template<class T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &elem : a) {
in >> elem;
}
return in;
}
template<class T>
ostream &operator<<(ostream &in, vector<T> &a) {
for (auto &elem : a) {
in << elem << ' ';
}
return in;
}
int n;
const int k = 100;
const int logn = 18;
const int MAXN = 1e5 + 100;
int b[MAXN];
int b1[MAXN];
vec<int> t;
void upd(int v, int x) {
for (int i = v; i < (int) t.size(); i |= i + 1) {
t[i] += x;
}
}
int get(int v) {
int s = 0;
for (int i = v; i > -1; i = (i & (i + 1)) - 1) {
s += t[i];
}
return s;
}
int low_b(int val) {
int cur = -1;
for (int i = logn; i > -1; i--) {
if (cur + (1 << i) >= n) continue;
if (cur + (1 << i) + t[cur + (1 << i)] < val) {
cur += (1 << i);
val -= t[cur];
}
}
return (cur + 1);
}
void build(int ind) {
int L = ind * k, r = min(ind * k + k, n);
vec<int> a;
for (int i = L; i < r; ++i) {
if (!a.size()) {
a.push_back(b[i]);
upd(b[i], 1);
} else {
int cur = low_b(b[i]);
a.push_back(cur);
upd(cur, 1);
}
}
sort(all(a));
for (int i = 0; i < a.size(); ++i) {
b1[i + L] = a[i];
}
for (auto elem:a) {
upd(elem, -1);
}
}
int getans(int i) {
int block0 = i / k;
int cur = b[i];
for (int j = i + 1; j < min(n, block0 * k + k); ++j) {
cur += (bool) (b[j] <= cur);
}
for (int j = block0 + 1; j * k < n; ++j) {
int l0 = j * k;
int r0 = min(n, j * k + k);
int c = upper_bound(b1 + l0, b1 + r0, cur) - (b1 + l0);
cur += c;
}
return cur;
}
inline void run() {
//int n;
cin >> n;
t.resize(n);
for (int i = 0; i < n; ++i) {
cin >> b[i];
b[i] = i - b[i];
}
for (int i = 0; i * k < n; ++i) {
build(i);
}
int q;
cin >> q;
while (q--) {
int type;
cin >> type;
if (type == 1) {
int i;
int x;
cin >> i >> x;
--i;
b[i] = i - x;
build(i / k);
} else {
int i;
cin >> i;
--i;
cout << getans(i) + 1 << '\n';
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
cout << setprecision(20);
//cin >> tt;
while (tt--) {
run();
cout << '\n';
}
return 0;
}
|
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <cassert>
#include <unistd.h>
using namespace std;
#define LOG(f...) fprintf(stderr, f)
#define all(cont) begin(cont), end(cont)
using ll = long long;
template<class T> void read(T &x) {
char ch; x = 0;
int f = 1;
while (isspace(ch = getchar()));
if (ch == '-') ch = getchar(), f = -1;
do x = x * 10 + (ch - '0'); while(isdigit(ch = getchar()));
x *= f;
}
template<class T, class ...A> void read(T &x, A&... args) { read(x); read(args...); }
const int B = 1024;
const int N = 100000;
struct pt {
int x, y;
pt() = default;
pt(int _x, int _y) : x(_x), y(_y) {}
};
int a[N];
vector<pt> t[N / B + 2][B * 2 + 2];
vector<pt> composite(const vector<pt> &l, const vector<pt> &r) {
vector<pt> res;
res.reserve(l.size() + r.size());
auto itl = begin(l), itr = begin(r), tl = end(l), tr = end(r);
while (itl != tl && itr != tr) {
if (itl->y == itr->x)
res.emplace_back(itl->x, itr->y), ++itl, ++itr;
else if (itl->y < itr->x) {
if (itr != begin(r)) res.emplace_back(itl->x, prev(itr)->y + itl->y - prev(itr)->x);
++itl;
}
else {
if (itl != begin(l)) {
int pos = itr->x - prev(itl)->y + prev(itl)->x;
if (pos < itl->x)
res.emplace_back(itr->x - prev(itl)->y + prev(itl)->x, itr->y);
}
++itr;
}
}
for (; itl != tl; ++itl)
res.emplace_back(itl->x, r.back().y + itl->y - r.back().x);
for (; itr != tr; ++itr)
res.emplace_back(l.back().x + itr->x - l.back().y, itr->y);
assert(is_sorted(all(res), [](const pt &a, const pt &b) { return a.x < b.x; }));
assert(is_sorted(all(res), [](const pt &a, const pt &b) { return a.y < b.y; }));
return res;
}
int eval(const vector<pt> &a, int x) {
auto it = prev(partition_point(all(a), [&](const pt &a) { return a.x <= x; }));
return it->y + (x - it->x);
}
void build(vector<pt> *t, int x, int l, int r) {
if (l == r) {
if (a[l] == 0) t[x] = {pt(0, 1)};
else t[x] = {pt(0, 0), pt(a[l], a[l] + 1)};
return;
}
int mid = (l + r) >> 1;
build(t, x << 1, l, mid);
build(t, x << 1 | 1, mid + 1, r);
t[x] = composite(t[x << 1], t[x << 1 | 1]);
}
void update(vector<pt> *t, int x, int l, int r, int pos) {
if (l == r) {
if (a[l] == 0) t[x] = {pt(0, 1)};
else t[x] = {pt(0, 0), pt(a[l], a[l] + 1)};
return;
}
int mid = (l + r) >> 1;
pos <= mid ? update(t, x << 1, l, mid, pos) : update(t, x << 1 | 1, mid + 1, r, pos);
t[x] = composite(t[x << 1], t[x << 1 | 1]);
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n, qc;
read(n);
for (int i = 0; i < n; ++i)
read(a[i]), a[i] = i - a[i];
int bc = (n - 1) / B + 1;
for (int b = 0; b < bc; ++b) {
int bl = b * B, br = min(n, (b + 1) * B);
build(t[b], 1, bl, br - 1);
}
read(qc);
while (qc--) {
int opt, p;
read(opt, p); --p;
int b = p / B, bl = b * B, br = min(n, (b + 1) * B);
if (opt == 1) {
read(a[p]);
a[p] = p - a[p];
update(t[p / B], 1, bl, br - 1, p);
}
else {
int res = a[p];
for (int i = p + 1; i < br; ++i)
res += a[i] <= res;
for (int i = b + 1; i < bc; ++i)
res = eval(t[i][1], res);
printf("%d\n", res + 1);
}
}
return 0;
} |
#include <iostream>
using namespace std;
const int n = 100352;
const int lgbt = 9;
const int b = 1 << lgbt;
int indexes[lgbt + 1][n];
int values[lgbt + 1][n];
int set[n];
void merge(int k, int l) {
int end = k + (1 << l);
int mid = k + (1 << (l - 1));
int x = mid;
int y = k;
for (int z = k; z < end; z++) {
if (y < mid && (x == end || values[l - 1][y] + (x - mid) < values[l - 1][x])) {
indexes[l][z] = indexes[l - 1][y];
values[l][z] = values[l - 1][y] + (x - mid);
y++;
} else {
indexes[l][z] = indexes[l - 1][x];
values[l][z] = values[l - 1][x];
x++;
}
}
}
void assign(int k) {
for (int x = k; x < k + b; x++) {
set[indexes[lgbt][x]] = values[lgbt][x];
}
}
int find(int k, int x) {
int upper = b;
int lower = 0;
while (upper > lower) {
int mid = (upper + lower) / 2;
if (x + mid < values[lgbt][k + mid]) {
upper = mid;
} else {
lower = mid + 1;
}
}
return x + upper;
}
void update(int k) {
for (int l = 1; l <= lgbt; l++) {
k = (k >> l) << l;
merge(k, l);
}
assign(k);
}
int calc(int k) {
int x = set[k];
k = ((k >> lgbt) << lgbt) + b;
for (; k < n; k += b) {
x = find(k, x);
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int nActual;
cin >> nActual;
for (int x = 0; x < n; x++) {
indexes[0][x] = x;
if (x < nActual) {
int a;
cin >> a;
values[0][x] = x - a;
} else {
values[0][x] = x;
}
}
for (int l = 1; l <= lgbt; l++) {
for (int k = 0; k < n; k += 1 << l) {
merge(k, l);
}
}
for (int k = 0; k < n; k += b) {
assign(k);
}
int q;
for (cin >> q; q; q--) {
int type, k;
cin >> type >> k;
k--;
if (type == 1) {
int a;
cin >> a;
values[0][k] = k - a;
update(k);
} else {
cout << calc(k) + 1 << ' ';
}
}
cout << endl;
return 0;
} |
// Author: wlzhouzhuan
#pragma GCC optimize(2,3,"Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fir first
#define sec second
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, l, r) for (int i = l; i >= r; i--)
#define mset(s, t) memset(s, t, sizeof(s))
#define mcpy(s, t) memcpy(s, t, sizeof(t))
#define poly vector<int>
#define SZ(x) (int(x.size()))
template<typename T1, typename T2> void ckmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> void ckmax(T1 &a, T2 b) { if (a < b) a = b; }
int read() {
int x = 0, f = 0; char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template<typename T> void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template<typename T> void print(T x, char let) {
print(x), putchar(let);
}
const int N = 100005;
const int inf = 1e9;
const int B = 300;
int L[N / B + 3], R[N / B + 3];
int a[N], be[N], n, q;
// f[i][j]: 通过第 i 块，使得数值 +=j 的读入范围 [f[i][j],f[i][j+1])
// f[i][j] 即为下界
int c[N], f[N / B + 3][B + 1];
#define ls (u << 1)
#define rs (u << 1 | 1)
int mn[N << 2], pos[N << 2], tag[N << 2];
inline void pushup(int u) {
if (mn[ls] <= mn[rs]) mn[u] = mn[ls], pos[u] = pos[ls];
else mn[u] = mn[rs], pos[u] = pos[rs];
}
inline void pushtag(int u, int dlt) {
mn[u] += dlt, tag[u] += dlt;
}
inline void pushdown(int u) {
if (tag[u]) {
pushtag(ls, tag[u]), pushtag(rs, tag[u]);
tag[u] = 0;
}
}
void build(int u, int l, int r) {
if (l == r) {
mn[u] = c[l], pos[u] = l;
return ;
}
int mid = l + r >> 1;
build(ls, l, mid), build(rs, mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
pushtag(u, -1);
return ;
}
pushdown(u);
int mid = l + r >> 1;
if (ql <= mid) update(ls, l, mid, ql, qr);
if (qr > mid) update(rs, mid + 1, r, ql, qr);
pushup(u);
}
void ban(int u, int l, int r, int pos) {
if (l == r) {
mn[u] = inf;
return ;
}
pushdown(u);
int mid = l + r >> 1;
if (pos <= mid) ban(ls, l, mid, pos);
else ban(rs, mid + 1, r, pos);
pushup(u);
}
void rebuild(int id, int l, int r) {
int len = r - l + 1;
for (int j = l; j <= r; j++) c[j - l + 1] = a[j];
memset(mn, 0, 16 * len);
memset(pos, 0, 16 * len);
memset(tag, 0, 16 * len);
build(1, 1, len);
for (int j = 1; j <= len; j++) {
f[id][j] = max(f[id][j - 1], mn[1]);
int who = pos[1];
if (who != len) update(1, 1, len, who + 1, len);
ban(1, 1, len, who);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = i - read(), be[i] = (i - 1) / B + 1;
for (int l = 1, r = B, id = 1; l <= n; l += B, r += B, id++) {
r = min(r, n), L[id] = l, R[id] = r;
rebuild(id, l, r);
}
q = read();
while (q--) {
int opt = read(), x = read();
if (opt == 1) {
int t = read();
a[x] = x - t;
rebuild(be[x], L[be[x]], R[be[x]]);
} else {
int now = a[x];
for (int i = x + 1; i <= R[be[x]]; i++) {
if (now >= a[i]) ++now;
}
// printf("after now = %d\n", now);
for (int i = be[x] + 1; i <= be[n]; i++) {
int pos = upper_bound(f[i] + 1, f[i] + (R[i] - L[i] + 1) + 1, now) - f[i];
now += pos - 1;
// printf("after block (%d, %d), now = %d\n", L[i], R[i], now);
// for (int j = 1; j <= R[i] - L[i] + 1; j++) printf("f[%d][%d] = %d\n", i, j, f[i][j]);
// puts("-----");
}
print(now, '\n');
// system("pause");
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define forg(i,x) for(register int i=fir[x];i;i=nxt[i])
#define uu unsigned
#define scanf a14=scanf
#define rint register int
#define fre(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout)
typedef long long ll;
typedef uu long long ull;
typedef pair<int,int>pii;
int a14;
inline int rd(int l,int r){return rand()%(r-l+1)+l;}
const int mxn=1e5+3,sq=400,qs=320;
int n,b[mxn],lp[mxn],rp[mxn],kn,be[mxn],po[mxn],qn;
int ju[mxn/sq+2][mxn],ad[mxn/sq+2][mxn/qs+1];
int TG;
struct shu{
int a[mxn],tg[mxn];
void add(int x){for(;x<=n;x+=x&-x){if(tg[x]!=TG)tg[x]=TG,a[x]=0;++a[x];}}
int ask(int x){
int su=0,p=0;
for(int i=1<<16;i;i>>=1){
if(p+i>=n)continue;
p+=i;if(tg[p]!=TG)tg[p]=TG,a[p]=0;
if(p+a[p]+su>=x)p-=i;else su+=a[p];
}
return p+1;
}
void gb(int t){for(int i=1;i<=n;++i){if(tg[i]!=TG)a[i]=0;ju[t][i]=ju[t][i-(i&-i)]+a[i];}for(int i=1;i<=n;++i)ju[t][i]+=i;}
}ar;
void add2(int t,int x,int y){
int k=(x-1)/qs;
for(int i=x;i<=(k+1)*qs;++i)ju[t][i]+=y;
for(++k;k*qs+1<=n;++k)ad[t][k]+=y;
}
int main(){
//cout<<(sizeof(ju)>>20)<<endl;
scanf("%d",&n);for(int i=1;i<=n;++i)scanf("%d",b+i),b[i]=i-b[i];scanf("%d",&qn);
for(int l=1,r;r!=n;l=r+1){r=min(l+sq-1,n);lp[++kn]=l,rp[kn]=r;for(int i=l;i<=r;++i)be[i]=kn;}
for(int t=1;t<=kn;++t){
++TG; for(int i=lp[t];i<=rp[t];++i)po[i]=ar.ask(b[i]),ar.add(po[i]);
ar.gb(t);
}
while(qn--){
int o,x,y;scanf("%d%d",&o,&x);if(o==1){
scanf("%d",&y);b[x]=x-y;int k=be[x],ls;
++TG;for(int i=lp[k];i<=rp[k];++i){
if(i<x)ar.add(po[i]);else{
ls=po[i],po[i]=ar.ask(b[i]),ar.add(po[i]);
if(ls==po[i])continue;
if(ls==po[i]-1){--ju[k][ls];continue;}
if(ls==po[i]+1){++ju[k][po[i]];continue;}
assert(i==x);
add2(k,ls,-1),add2(k,po[i],1);
}
}
}else{
int t=be[x],re=b[x];for(int i=x+1;i<=rp[t];++i)re+=b[i]<=re;
for(++t;t<=kn;++t)re=ju[t][re]+ad[t][(re-1)/qs];
printf("%d\n",re);
}
}
return 0;
}
|
//#pragma GCC target("avx,avx2")
//#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define debug(...) //ignore
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long double ld;
const int SZ = 1e5+10;
struct FT {
int s[SZ];
//vector<int> s;
//FT(int n) : s(n) {}
int N;
void init(int n) { fill(s,s+n, 0); N = n; } // { s.resize(n); }
void update(int pos, int dif) { // a[pos] += dif
for (; pos < N; pos |= pos + 1) s[pos] += dif;
}
int query(int pos) { // sum of values in [0, pos)
int res = 0;
for (; pos > 0; pos &= pos - 1) res += s[pos-1];
return res;
}
int lower_bound(int sum) {// min pos st sum of [0, pos] >= sum
// Returns n if no sum is >= sum, or -1 if empty sum is.
if (sum <= 0) return -1;
int pos = 0;
for (int pw = 1 << 25; pw; pw >>= 1) {
if (pos + pw <= N && s[pos + pw-1] < sum)
pos += pw, sum -= s[pos-1];
}
return pos;
}
};
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int n;
cin >> n;
vi larger(n);
rep(i,0,n) {
cin>>larger[i];
//larger[i] = i;
}
const int MAGIC = 550; // ~ sqrt n
struct block {
int lo = 1e9, hi = -1e9;
vi ans;
FT fw;
};
vi where(n);
rep(i,0,n) where[i] = i/MAGIC;
vector<block> blocks(where.back()+1);
rep(i,0,n) blocks[where[i]].hi = i+1;
for(int i = n; i--; ) blocks[where[i]].lo = i;
auto fix = [&](block &b, int HI) {
rep(i,b.lo,HI+1) b.fw.update(b.ans[i-b.lo],+1); // restore fenwick tree
for(int i = HI; i >= b.lo; --i) {
int idx = i - larger[i];
// want idx smallest which is free?
int q = b.fw.lower_bound(idx+1);
//assert(q != -1 && q != b.hi);
b.fw.update(q,-1);
b.ans[i-b.lo] = q;
}
};
for(auto& b : blocks) {
b.ans.resize(b.hi-b.lo,0);
b.fw.init(b.hi);
rep(q,0,b.hi) b.fw.update(q,+1);
for(int q : b.ans) b.fw.update(q,-1); // dummy updates
fix(b, b.hi-1);
}
auto update = [&](int i, int x) {
larger[i] = x;
fix(blocks[where[i]],i);
};
auto query = [&](int i) {
auto &b = blocks[where[i]];
int q = b.ans[i-b.lo];
rep(bi, where[i]+1, sz(blocks)) {
q = blocks[bi].fw.lower_bound(q+1);
//assert(q != -1 && q != blocks[bi].hi);
}
return q;
};
int q;
cin>>q;
rep(_,0,q) {
int t,i;
cin>>t>>i;
//t = rand()%2+1;
//i = rand()%n + 1;
--i;
if(t == 1) {
int x;
//x = rand()%(i+1);
cin>>x;
update(i,x);
}
else if(t == 2) {
int ans = query(i);
cout << ans+1 << "\n";
}
else assert(false);
}
}
|
/*
{
######################
# Author #
# Gary #
# 2021 #
######################
*/
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
inline int read(){
int x=0;
char ch=getchar();
while(ch<'0'||ch>'9'){
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x;
}
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
const int MAXN=1e5+1;
const int MAGIC=300;
int n;
struct FWTTT{
int tree[MAXN];
FWTTT(){
memset(tree,0,sizeof(tree));
}
void add(int pos,int val){
while(pos<=n){
tree[pos]+=val;
pos+=pos&-pos;
}
}
int lower_bound(int val){
int now=0;
int sum=0;
rl(i,16,0){
if(now+(1<<i)>n) continue;
if(sum+tree[now|(1<<i)]<val){
now|=1<<i;
sum+=tree[now];
}
}
return now+1;
}
int query(int pos){
int sum=0;
while(pos){
sum+=tree[pos];
pos^=pos&-pos;
}
return sum;
}
}fwt[MAXN/MAGIC+3];
vector<int> ope[MAXN/MAGIC+3];
int b[MAXN];
bool z[MAXN];
void build(int id){
z[id]=0;
for(auto it:ope[id]) fwt[id].add(it,-1);
ope[id].clear();
int l,r;
l=(id-1)*MAGIC+1;
r=min(n,id*MAGIC);
rb(i,l,r){
int x=fwt[id].lower_bound(b[i]);
ope[id].PB(x);
fwt[id].add(x,1);
}
}
int main(){
scanf("%d",&n);
rb(i,1,n) b[i]=read(),b[i]=i-b[i];
rb(i,1,(n+MAGIC-1)/MAGIC){
z[i]=1;
rb(j,1,n) fwt[i].tree[j]=j&-j;
}
int q;
scanf("%d",&q);
while(q--){
int ty;
ty=read();
if(ty==1){
int p,x;
p=read();
x=read();
b[p]=p-x;
p=(p+MAGIC-1)/MAGIC;
z[p]=1;
}
else{
int x;
x=read();
int ans=b[x];
for(int i=x+1;i<=n;){
if(i%MAGIC==1){
if(z[i/MAGIC+1]) build(i/MAGIC+1);
ans=fwt[i/MAGIC+1].query(ans);
i+=MAGIC;
}
else{
ans+=ans>=b[i];
i++;
}
}
printf("%d\n",ans);
}
}
return 0;
} |
#include <iostream>
#include <cstdio>
#include <algorithm>
const int nn = 1e5 + 5;
const int inf = 1e9;
struct node {
int val, lazy, pos;
#define val(p) tree[p].val
#define lazy(p) tree[p].lazy
#define pos(p) tree[p].pos
#define ls (p << 1)
#define rs (p << 1 | 1)
} tree[nn << 3];
void update(int p) {
if (val(ls) < val(rs)) {
val(p) = val(ls);
pos(p) = pos(ls);
} else {
val(p) = val(rs);
pos(p) = pos(rs);
}
}
int c[nn];
void build(int p, int l, int r) {
if (l == r) {
val(p) = c[l];
pos(p) = l;
return;
}
int mid = l + r >> 1;
build(ls, l, mid);
build(rs, mid + 1, r);
update(p);
}
void pushdown(int p) {
if (!lazy(p)) return;
lazy(ls) += lazy(p);
val(ls) += lazy(p);
lazy(rs) += lazy(p);
val(rs) += lazy(p);
lazy(p) = 0;
}
void modify(int p, int l, int r, int pos, int val) {
if (l == r) {
val(p) = val;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (pos <= mid) modify(ls, l, mid, pos, val);
else modify(rs, mid + 1, r, pos, val);
update(p);
}
void add(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
val(p)--; lazy(p)--;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (ql <= mid) add(ls, l, mid, ql, qr);
if (mid < qr) add(rs, mid + 1, r, ql, qr);
update(p);
}
int a[nn], stack[3005][3005], lenth[nn];
void build_b(int p, int l, int r) {
for (int i = 1; i <= 2000; i++)
tree[i] = (node){0, 0, 0};
for (int i = l; i <= r; i++) c[i - l + 1] = a[i];
int len = r - l + 1;
build(1, 1, len);
for (int i = 1; i <= len; i++) {
stack[p][i] = std::max(val(1), stack[p][i - 1]);
int pos = pos(1);
if (pos != len) add(1, 1, len, pos + 1, len);
modify(1, 1, len, pos, inf);
}
stack[p][lenth[p] + 1] = inf;
}
int n, m, block, bl[nn], l[nn], r[nn];
int main() {
scanf("%d", &n);
block = 100;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
bl[i] = (i - 1) / block + 1;
}
for (int i = 1; i <= bl[n]; i++) {
l[i] = i * block - block + 1;
r[i] = std::min(n, i * block);
lenth[i] = r[i] - l[i] + 1;
build_b(i, l[i], r[i]);
}
scanf("%d", &m);
while (m--) {
int opt, x;
scanf("%d %d", &opt, &x);
if (opt == 1) {
scanf("%d", a + x);
build_b(bl[x], l[bl[x]], r[bl[x]]);
} else {
int ans = a[x];
for (int i = x + 1; i <= r[bl[x]]; i++) ans += (ans >= a[i]);
for (int i = bl[x] + 1; i <= bl[n]; i++) {
int pos = std::upper_bound(stack[i] + 1, stack[i] + lenth[i] + 2, ans) - stack[i];
ans += pos - 1;
}
printf("%d\n", n - ans);
}
}
} |
#include <bits/stdc++.h>
#define range(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ar array
using namespace std;
typedef long long ll;
typedef double ld;
typedef unsigned long long ull;
const ll INF = 2e18;
const int INFi = 2e9 + 5;
const int maxN = 1e5 + 1;
const int md = 1e9 + 7;
const int K = 250;
int n;
int b[maxN];
int bl[maxN];
struct fenwick {
int n{};
vector<int> fenw{};
void build(int k) {
n = k;
fenw.resize(n);
}
void upd(int i, int x) {
for (; i < n; i = i | (i + 1)) fenw[i] += x;
}
int get(int i) {
int res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) res += fenw[i];
return res;
}
int get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
void clear(vector<int> &was) {
for(auto &x : was) {
upd(x, -1);
}
}
} F;
// K log N
void rebuild(int block) {
int l = block * K;
int r = min(l + K, n);
vector<int> res;
for(int i = l; i < r; ++i) {
if (res.empty()) {
res.push_back(b[i]);
F.upd(b[i], 1);
continue;
}
int cur = -1;
int ad = 0;
for(int j = 18; j >= 0; --j) {
int t = 1 << j;
if (cur + t < n && cur + t + F.fenw[cur + t] + ad < b[i]) {
cur += t;
ad += F.fenw[cur];
}
}
cur++;
res.push_back(cur);
F.upd(cur, 1);
}
F.clear(res);
sort(all(res));
for(int i = l; i < r; ++i) {
bl[i] = res[i - l];
}
}
void upd(int i, int x) {
b[i] = x;
b[i] = i - b[i];
rebuild(i / K);
}
// N / K log N
int get(int i) {
int bq = i / K;
int r = min((bq + 1) * K, n);
int to = b[i];
for(int j = i + 1; j < r; ++j) {
if (b[j] <= to) to++;
}
int l = bq * K;
for(int j = bq + 1; j * K < n; ++j) {
r += K;
l += K;
if (r > n) r = n;
int c = (int)(upper_bound(bl + l, bl + r, to) - (bl + l));
to += c;
}
return to;
}
void solve() {
cin >> n;
F.build(n + 5);
range(i, n) {
cin >> b[i];
b[i] = i - b[i];
}
for(int j = 0; j * K < n; ++j) {
rebuild(j);
}
int q; cin >> q;
range(_, q) {
int t; cin >> t;
if (t == 1) {
int i, x; cin >> i >> x;
i--;
upd(i, x);
} else {
int i; cin >> i;
i--;
cout << get(i) + 1 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// cout << setprecision(15) << fixed;
int tests = 1;
// cin >> tests;
range(_, tests) {
solve();
}
return 0;
} |
#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <exception>
#include <map>
#include <memory>
#include <queue>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
#define mp(x, y) make_pair(x, y)
const int N = 1e5 + 5, bs = 320, mod = 1e9 + 7;
int n, q, b[N], c[N];
int t[N << 2], lz[N << 2], bit[N];
vector<int> v[550];
bool needLoad[550];
void add(int x, int v) {
while (x <= n) bit[x] += v, x += x & -x;
}
int query(int x) {
int ans = 0, sum = 0;
for (int i = 1 << 16; i; i >>= 1)
if ((ans | i) <= n && sum + bit[ans | i] < x) ans |= i, sum += bit[ans];
return ans + 1;
}
void load(int x) {
int l = max(1, x * bs), r = min(n, (x + 1) * bs - 1);
v[x].clear();
for (int i = l; i <= r; i++) {
v[x].push_back(query(b[i]));
add(v[x].back(), 1);
}
for (int i = v[x].size() - 1; i >= 0; i--) add(v[x][i], -1);
sort(v[x].begin(), v[x].end());
needLoad[x] = false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), b[i] = i - b[i];
for (int i = 1; i <= n; i++) add(i, 1);
for (int i = 0; i <= n / bs; i++) needLoad[i] = true;
scanf("%d", &q);
while (q--) {
int op, x, y;
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%d", &y);
b[x] = x - y;
needLoad[x / bs] = true;
} else {
int rkx = b[x];
int las = min(n, (x / bs + 1) * bs - 1);
for (int i = x + 1; i <= las; i++)
if (b[i] <= rkx) rkx++;
if (las + 1 <= n) {
las = (las + 1) / bs;
for (int i = las; i <= n / bs; i++) {
if (needLoad[i]) load(i);
int p = upper_bound(v[i].begin(), v[i].end(), rkx) - v[i].begin();
rkx += p;
}
}
printf("%d\n", rkx);
}
}
} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(x,n) for(int x=0;x<n;x++)
#define mp make_pair
#define PI 3.14159265358979323846264338327950288
typedef long long ll;
typedef pair<int,int> ii;
const int MX = 1e5 + 1;
const int CHKSIZE = 100;
const int CHKS = MX/CHKSIZE + 1;
class fenwickTree {
public:
int* tree;
int size;
int get(int index) {
index++; // dummy node indexing
int ret = 0;
while(index > 0) {
ret += tree[index];
index -= (index & -index);
}
return ret;
}
void update(int index, int delta) {
if(index >= size) return;
index++; // dummy node indexing
while(index <= size) {
tree[index] += delta;
index += (index & -index);
}
}
int lbound(int x) {
int curr = 0, currsum = 0;
for(int i = 20; i >= 0; i--) {
int bit = (1 << i);
int up = curr + bit;
if(up > size || currsum + tree[up] >= x) continue;
curr = up;
currsum += tree[up];
}
return curr;
}
fenwickTree() {
size = MX;
tree = new int[size+1]; // +1 for dummy node at 0
memset(tree, 0, sizeof(int)*(size+1));
for(int i = 1; i < size; i++) {
update(i, 1);
}
}
};
int n;
int arr[MX], nxt[2*MX];
fenwickTree tree;
vector<int> updates[CHKS];
void upd1(int i, int val) {
int idx = i/CHKSIZE;
int start = idx*CHKSIZE;
int end = min(idx*CHKSIZE + CHKSIZE, n) - 1;
arr[i] = val;
for(int j = start; j <= end; j++) {
int x = tree.lbound(arr[j]);
tree.update(x, 1);
updates[idx][j - start] = x;
}
for(int j = end; j >= start; j--) {
tree.update(updates[idx][j - start], -1);
}
sort(updates[idx].begin(), updates[idx].end());
}
int query2(int i) {
int curr = arr[i];
i++;
while(i < n && nxt[i] == -1) {
if(arr[i] <= curr) curr++;
i++;
}
while(i < n) {
int idx = i/CHKSIZE;
curr += upper_bound(updates[idx].begin(), updates[idx].end(), curr) - updates[idx].begin();
i = nxt[i];
}
return n - curr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
memset(nxt, -1, sizeof nxt);
for(int i = 0; i < 2*MX; i += CHKSIZE) {
nxt[i] = i + CHKSIZE;
}
scanf("%d", &n);
FOR(i,n) {
scanf("%d", &arr[i]);
}
int chks = (n + CHKSIZE - 1)/CHKSIZE;
FOR(i,chks) {
updates[i].resize(CHKSIZE, 2*MX);
upd1(CHKSIZE * i, arr[CHKSIZE * i]);
}
int q;
scanf("%d", &q);
while(q--) {
int t;
scanf("%d", &t);
if(t == 1) {
int i, x;
scanf("%d %d", &i, &x);
i--;
upd1(i, x);
}
else {
int i;
scanf("%d", &i);
i--;
printf("%d\n", query2(i));
}
}
}
// UPDATE N WHEN UR DONE AAAAAAAAAAAAAAAAAAAAAAAAAAA (if it applies lol)
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=300,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
cnt[k].add(mn[i],-1);
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+cnt[k].f[mn[i]]<rmd[i]+d)
{
rmd[i]=rmd[i]-cnt[k].f[mn[i]]+d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]-1+d>=rmd[i])
{
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=400,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
cnt[k].add(mn[i],-1);
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+cnt[k].f[mn[i]]<rmd[i]+d)
{
rmd[i]=rmd[i]-cnt[k].f[mn[i]]+d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]-1+d>=rmd[i])
{
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(x,n) for(int x=0;x<n;x++)
#define mp make_pair
#define PI 3.14159265358979323846264338327950288
typedef long long ll;
typedef pair<int,int> ii;
const int MX = 1e5 + 1;
const int CHKSIZE = 216;
const int CHKS = MX/CHKSIZE + 1;
class fenwickTree {
public:
int* tree;
int size;
int get(int index) {
index++; // dummy node indexing
int ret = 0;
while(index > 0) {
ret += tree[index];
index -= (index & -index);
}
return ret;
}
void update(int index, int delta) {
if(index >= size) return;
index++; // dummy node indexing
while(index <= size) {
tree[index] += delta;
index += (index & -index);
}
}
int lbound(int x) {
int curr = 0, currsum = 0;
for(int i = 20; i >= 0; i--) {
int bit = (1 << i);
int up = curr + bit;
if(up > size || currsum + tree[up] >= x) continue;
curr = up;
currsum += tree[up];
}
return curr;
}
fenwickTree() {
size = MX;
tree = new int[size+1]; // +1 for dummy node at 0
memset(tree, 0, sizeof(int)*(size+1));
for(int i = 1; i < size; i++) {
update(i, 1);
}
}
};
int n;
int arr[MX], nxt[2*MX];
fenwickTree tree;
vector<int> updates[CHKS];
void upd1(int i, int val) {
int idx = i/CHKSIZE;
int start = idx*CHKSIZE;
int end = min(idx*CHKSIZE + CHKSIZE, n) - 1;
arr[i] = val;
for(int j = start; j <= end; j++) {
int x = tree.lbound(arr[j]);
tree.update(x, 1);
updates[idx][j - start] = x;
}
for(int j = end; j >= start; j--) {
tree.update(updates[idx][j - start], -1);
}
sort(updates[idx].begin(), updates[idx].end());
}
int query2(int i) {
int curr = arr[i];
i++;
while(i < n && nxt[i] == -1) {
if(arr[i] <= curr) curr++;
i++;
}
while(i < n) {
int idx = i/CHKSIZE;
curr += upper_bound(updates[idx].begin(), updates[idx].end(), curr) - updates[idx].begin();
i = nxt[i];
}
return n - curr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
memset(nxt, -1, sizeof nxt);
for(int i = 0; i < 2*MX; i += CHKSIZE) {
nxt[i] = i + CHKSIZE;
}
scanf("%d", &n);
FOR(i,n) {
scanf("%d", &arr[i]);
}
int chks = (n + CHKSIZE - 1)/CHKSIZE;
FOR(i,chks) {
updates[i].resize(CHKSIZE, 2*MX);
upd1(CHKSIZE * i, arr[CHKSIZE * i]);
}
int q;
scanf("%d", &q);
while(q--) {
int t;
scanf("%d", &t);
if(t == 1) {
int i, x;
scanf("%d %d", &i, &x);
i--;
upd1(i, x);
}
else {
int i;
scanf("%d", &i);
i--;
printf("%d\n", query2(i));
}
}
}
// UPDATE N WHEN UR DONE AAAAAAAAAAAAAAAAAAAAAAAAAAA (if it applies lol)
|
#include <bits/stdc++.h>
const int N = 1 << 17;
const int BLOCK = 1304;
const int BLOCK1 = 1 << 11;
const int BLOCK_NUM = 110;
struct Item{
int id, pos;
};
int b[N];
int l[N], r[N], block_id[N];
std::vector <Item> vec[BLOCK_NUM][BLOCK1 << 1];
int right_bound[BLOCK_NUM][BLOCK1 << 1];
std::vector <Item> merge(std::vector <Item> vec1, const std::vector <Item> &vec2, int r_bound){
if (vec2.empty()){
return vec1;
}
int sz1 = vec1.size(), sz2 = vec2.size();
for (int i = 0, j = 0; i < sz1; ++ i){
while (j < sz2 && vec2[j].pos - j - 1 < vec1[i].pos){
++ j;
}
if (j < sz2){
int cur = vec2[j].pos, num = cur - j - 1;
vec1[i].pos = cur - 1 - (num - vec1[i].pos);
}
else{
int cur = r_bound + 1, num = r_bound - int(vec2.size());
vec1[i].pos = cur - 1 - (num - vec1[i].pos);
}
}
std::vector <Item> result;
for (int i = 0, j = 0; i < sz1 || j < sz2; ){
if (j == sz2 || (i < sz1 && vec1[i].pos < vec2[j].pos)){
result.push_back(vec1[i ++]);
}
else{
result.push_back(vec2[j ++]);
}
}
return result;
}
int query_pos(int prev_pos, int bid){
auto &vector = vec[bid][1];
int left = 0, right = vector.size();
while (left < right){
int mid = (left + right) / 2;
int num = vector[mid].pos - mid - 1;
if (num < prev_pos){
left = mid + 1;
}
else{
right = mid;
}
}
if (left < int(vector.size())){
int cur = vector[left].pos, num = cur - left - 1;
return cur - 1 - (num - prev_pos);
}
int cur = r[bid] + 1, num = r[bid] - int(vector.size());
return cur - 1 - (num - prev_pos);
}
int main(){
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++ i){
scanf("%d", &b[i]);
}
int block_num = 0;
memset(l, 0x3f, sizeof(l));
for (int i = 1; i <= n; ++ i){
int bid;
bid = block_id[i] = i / BLOCK;
l[bid] = std::min(l[bid], i);
r[bid] = std::max(r[bid], i);
block_num = std::max(block_num, bid + 1);
}
for (int i = 0; i < block_num; ++ i){
for (int j = l[i]; j <= r[i]; ++ j){
vec[i][j - l[i] + BLOCK1] = {Item{j, j - b[j]}};
right_bound[i][j - l[i] + BLOCK1] = j;
}
for (int j = BLOCK1 - 1; j; -- j){
vec[i][j] = merge(vec[i][j << 1], vec[i][j << 1 | 1], right_bound[i][j << 1 | 1]);
right_bound[i][j] = vec[i][j << 1 | 1].empty() ? right_bound[i][j << 1] : right_bound[i][j << 1 | 1];
}
}
int test;
scanf("%d", &test);
while (test --){
int type;
scanf("%d", &type);
if (type == 1){
int pos, val;
scanf("%d%d", &pos, &val);
b[pos] = val;
int bid = block_id[pos];
int seg_pos = pos - l[bid] + BLOCK1;
vec[bid][seg_pos] = {Item{pos, pos - val}};
for (seg_pos >>= 1; seg_pos; seg_pos >>= 1){
vec[bid][seg_pos] = merge(vec[bid][seg_pos << 1], vec[bid][seg_pos << 1 | 1], right_bound[bid][seg_pos << 1 | 1]);
}
}
else{
int pos;
scanf("%d", &pos);
int bid = block_id[pos];
int cur = -1;
for (auto item : vec[bid][1]){
if (pos == item.id){
cur = item.pos;
break;
}
}
for (int i = bid; i < block_num - 1; ++ i){
cur = query_pos(cur, i + 1);
}
printf("%d\n", cur);
}
}
return 0;
} |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define lowbit(x) ((x)&(-(x)))
#define mid ((l+r)>>1)
#define lson rt<<1, l, mid
#define rson rt<<1|1, mid+1, r
#define fors(i, a, b) for(int i = (a); i < (b); ++i)
#define all(vec) vec.begin(),vec.end()
using namespace std;
const int B = sqrt(1e5 + 5);
const int maxn = 1e5 + 5;
int bel[maxn], L[maxn], R[maxn];
int n, b[maxn];
#define P pair<int,int>
vector<int> t[maxn];
void build(int rt, int l, int r){
if(l == r){
t[rt].clear();
t[rt].pb(0); t[rt].pb(b[l]+1);
return;
}
t[rt].resize(r-l+2);
build(lson); build(rson);
for(int i = 0, j = 0; i < t[rt<<1].size(); ++i){
int l = t[rt<<1][i], r;
if(i+1==t[rt<<1].size()) r = n; else r = t[rt<<1][i+1]-1;
while(j-i < t[rt<<1|1].size() && r+i >= t[rt<<1|1][j-i]){
t[rt][j] = max(t[rt<<1|1][j-i]-i, l);
j++;
}
}return;
}
vector<int> ps[maxn];
void sol(int id){
build(1, L[id], R[id]);
ps[id] = t[1]; return;
}
int main()
{
cin>>n; bel[0] = -1;
fors(i,1,n+1) {
scanf("%d", &b[i]); b[i] = i-b[i]-1;
bel[i] = i/B;
if(bel[i]!=bel[i-1]) L[bel[i]] = i;
R[bel[i]] = i;
}
fors(i,1/B,n/B+1)
{
sol(i);
}
int q; cin>>q;
while(q--){
int op; scanf("%d", &op);
if(op == 1){
int i, x; scanf("%d%d", &i, &x);
b[i] = i-1-x; sol(bel[i]);
}else{
int x; scanf("%d", &x);
int ans = b[x]+1;
fors(i,x+1,R[bel[x]]+1) if(b[i]+1 <= ans) ans++;
fors(i,bel[x]+1,n/B+1) ans += upper_bound(all(ps[i]), ans)-ps[i].begin()-1;
printf("%d\n", ans);
}
}
return 0;
}
/*
5
0 1 0 0 4
5
2 1
2 2
2 3
2 4
2 5
*/
|
#include<iostream>
#include<cstdio>
#include<cassert>
#include<ctime>
#include<vector>
#include<algorithm>
using namespace std;
const int N=100005,B=55;
int n,m,Q;
int a[N],b[N];
struct BIT
{
int C[N];
int lowbit(int x)
{
return x&-x;
}
void add(int x,int y)
{
for(int i=x;i<=n;i+=lowbit(i))
C[i]+=y;
return;
}
int getsum(int x)
{
int res=0;
for(int i=x;i>0;i-=lowbit(i))
res+=C[i];
return res;
}
}T;
int bel[N];
struct Block
{
int l,r;
int p[B+5];
}block[N/B+5];
void update(int k)
{
vector<int>pos;
for(int i=block[k].l;i<=block[k].r;i++)
{
int l=1,r=n,p=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(mid+T.getsum(mid)>=a[i]) p=mid,r=mid-1;
else l=mid+1;
}
if(p==-1) exit(1);
pos.emplace_back(p);
T.add(p,1);
}
// for(int v=0;v<=block[k].r-block[k].l+1;v++)
// {
// cerr<<"now"<<v<<" "<<T.getsum(v)<<"\n";
// }
for(int v=0;v<=block[k].r-block[k].l+1;v++)
{
int l=v>0?block[k].p[v-1]:0,r=n,ans=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(T.getsum(mid)<=v) ans=mid,l=mid+1;
else r=mid-1;
}
if(ans==-1) exit(1);
block[k].p[v]=ans;
}
for(int p:pos)
T.add(p,-1);
return;
}
int query(int x)
{
int ans=a[x];
for(int i=x+1;i<=block[bel[x]].r;i++)
if(ans>=a[i]) ans++;
for(int i=bel[x]+1;i<=m;i++)
{
assert(block[i].r-block[i].l+1+1<B+5);
int v=lower_bound(block[i].p,block[i].p+block[i].r-block[i].l+1+1,ans)-block[i].p;
ans+=v;
}
return ans;
}
int main()
{
// freopen("data.in","r",stdin);
// freopen("data.out","w",stdout);
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&b[i]);
for(int i=1;i<=n;i++)
a[i]=i-b[i];
for(int i=1;i<=n;i++)
bel[i]=(i-1)/B+1;
m=(n-1)/B+1;
for(int i=1;i<=m;i++)
block[i].l=(i-1)*B+1,block[i].r=min(i*B,n);
for(int k=1;k<=m;k++)
{
vector<int>pos;
for(int i=block[k].l;i<=block[k].r;i++)
{
int l=1,r=n,p=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(mid+T.getsum(mid)>=a[i]) p=mid,r=mid-1;
else l=mid+1;
}
if(p==-1) exit(1);
pos.emplace_back(p);
T.add(p,1);
}
for(int v=0;v<=block[k].r-block[k].l+1;v++)
{
int l=v>0?block[k].p[v-1]:0,r=n,ans=-1;
while(l<=r)
{
int mid=(l+r)/2;
if(T.getsum(mid)<=v) ans=mid,l=mid+1;
else r=mid-1;
}
if(ans==-1) exit(1);
block[k].p[v]=ans;
}
for(int p:pos)
T.add(p,-1);
}
scanf("%d",&Q);
int s=0,t=0;
while(Q--)
{
// cerr<<"solve"<<Q<<"\n";
// if(Q%10000==0) cerr<<"now"<<Q<<" "<<(double)s/CLOCKS_PER_SEC<<" "<<(double)t/CLOCKS_PER_SEC<<"\n";
if((double)clock()/CLOCKS_PER_SEC>4.9)
{
cout<<"now"<<Q<<" "<<(double)s/CLOCKS_PER_SEC<<" "<<(double)t/CLOCKS_PER_SEC<<"\n";
exit(0);
}
int op,i;
scanf("%d",&op);
if(op==1)
{
int x;
scanf("%d%d",&i,&x);
int st=clock();
b[i]=x,a[i]=i-b[i];
update(bel[i]);
int ed=clock();
s+=ed-st;
}
else if(op==2)
{
scanf("%d",&i);
int st=clock();
printf("%d\n",query(i));
int ed=clock();
t+=ed-st;
}
}
return 0;
} |
// Author: HolyK
// Created: Thu Jul 8 20:33:54 2021
#include <bits/stdc++.h>
#define dbg(a...) fprintf(stderr, a)
template <class T, class U>
inline bool smin(T &x, const U &y) {
return y < x ? x = y, 1 : 0;
}
template <class T, class U>
inline bool smax(T &x, const U &y) {
return x < y ? x = y, 1 : 0;
}
using LL = long long;
using PII = std::pair<int, int>;
struct FenwickTree {
std::vector<int> c;
FenwickTree(int n) : c(n) {}
void add(int p, int x) {
assert(p);
for (; p < c.size(); p += p & -p) c[p] += x;
}
int ask(int p) {
int r = 0;
for (; p; p -= p & -p) r += c[p];
return r;
}
int find(int k) {
if (!k) return 1;
int p = 0;
for (int i = 1 << 16; i; i >>= 1) {
if (p + i < c.size() && k > c[p + i] + i) {
p += i, k -= c[p] + i;
}
}
return p + 1;
}
};
constexpr int T(400);
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
std::cin >> b[i];
b[i] = i - b[i] + 1;
}
int tot = (n - 1) / T + 1;
std::vector<FenwickTree> t(tot, n + 1);
for (int i = 0, x = 0; i < tot; i++, x += T) {
int y = std::min(x + T, n);
for (int j = x; j < y; j++) {
a[j] = t[i].find(b[j]);
// std::cout << j << " " << a[j] << "\n";
t[i].add(a[j], 1);
}
}
int q;
std::cin >> q;
while (q--) {
int opt, i;
std::cin >> opt >> i;
i--;
int bi = i / T, y = std::min(n, bi * T + T);
if (opt == 1) {
for (int j = y - 1; j >= i; j--) t[bi].add(a[j], -1);
std::cin >> b[i];
b[i] = i - b[i] + 1;
for (int j = i; j < y; j++) {
a[j] = t[bi].find(b[j]);
t[bi].add(a[j], 1);
}
} else {
int ans = b[i];
for (int j = i + 1; j < y; j++) if (b[j] <= ans) ans++;
for (int j = bi + 1; j < tot; j++) {
assert(ans <= n);
ans += t[j].ask(ans);
}
std::cout << ans << "\n";
}
}
return 0;
}
/*
3
0 0 0
7
2 1
2 2
2 3
1 2 1
2 1
2 2
2 3
5
0 1 2 3 4
15
2 1
2 2
1 2 1
2 2
2 3
2 5
1 3 0
1 4 0
2 3
2 4
2 5
1 4 1
2 3
2 4
2 5
*/
|
#include<bits/stdc++.h>
using namespace std;
namespace IO{
char pool[1<<20],*p1=pool,*p2=pool;
#define gc (p1==p2&&(p2=(p1=pool)+fread(pool,1,1<<20,stdin),p1==p2)?EOF:*p1++)
int R(){
int x=0,y=1;char ch=gc;
while(ch<'0'||ch>'9'){if(ch=='-')y=-1;ch=gc;}
while(ch>='0'&&ch<='9')x=x*10+(ch^48),ch=gc;
return x*y;
}
}
const int N=1e5+5,M=3005,inf=1e9;
int n,m,a[N],st[M][M],c[N];
int blen,ib[N],bl[M],br[M];
struct node{
int v,l,tag;
#define v(p) C[p].v
#define tag(p) C[p].tag
#define l(p) C[p].l
#define ls (p<<1)
#define rs (p<<1|1)
#define mid ((l+r)>>1)
};
struct tree{
node C[2005];
void push_up(int p){
if(v(ls)<v(rs))v(p)=v(ls),l(p)=l(ls);
else v(p)=v(rs),l(p)=l(rs);
}
void build(int p,int l,int r){
if(l==r){v(p)=c[l];l(p)=l;return;}
build(ls,l,mid);build(rs,mid+1,r);
push_up(p);
}
void push_down(int p){
if(!tag(p))return;
int k=tag(p);tag(p)=0;
tag(ls)+=k;v(ls)+=k;
tag(rs)+=k;v(rs)+=k;
}
void modify(int p,int l,int r,int x,int k){
if(l==r){v(p)=k;return;}
push_down(p);
if(x<=mid)modify(ls,l,mid,x,k);
else modify(rs,mid+1,r,x,k);
push_up(p);
}
void add(int p,int l,int r,int ql,int qr){
if(ql<=l&&r<=qr){v(p)--;tag(p)--;return;}
push_down(p);
if(ql<=mid)add(ls,l,mid,ql,qr);
if(mid<qr)add(rs,mid+1,r,ql,qr);
push_up(p);
}
void clear(){for(int i=1;i<=2000;i++)C[i]=(node){0,0,0};}
}T;
void build_b(int p,int l,int r){
for(int i=l;i<=r;i++)c[i-l+1]=a[i];
T.clear();int L=r-l+1;T.build(1,1,L);
for(int i=1;i<=L;i++){
int k=T.l(1);
st[p][i]=max(T.v(1),st[p][i-1]);
if(k!=L)T.add(1,1,L,k+1,L);
T.modify(1,1,L,k,inf);
}
st[p][L+1]=inf;
}
int main(){
n=IO::R();blen=100;
for(int i=1;i<=n;i++){
a[i]=IO::R();ib[i]=(i-1)/blen+1;
if(!bl[ib[i]])bl[ib[i]]=i;br[ib[i]]=i;
}
for(int i=1;i<=ib[n];i++)build_b(i,bl[i],br[i]);
for(m=IO::R();m--;){
int opt=IO::R(),x=IO::R();
if(opt==1)a[x]=IO::R(),build_b(ib[x],bl[ib[x]],br[ib[x]]);
else{
int ans=a[x];
for(int i=x+1;i<=br[ib[x]];i++)if(ans>=a[i])ans++;
for(int i=ib[x]+1;i<=ib[n];i++)
ans+=upper_bound(st[i]+1,st[i]+br[i]-bl[i]+3,ans)-st[i]-1;
printf("%d\n",n-ans);
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define LC k<<1
#define RC k<<1|1
#define IO cin.sync_with_stdio(false);
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define rep(i,a,n) for (int i=a;i<n;i++)
#define repn(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pern(i,a,n) for (int i=n;i>=a;i--)
typedef long long LL;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 110000;
const int M = 1100000;
const int mod = 1e9+7;
const int inf = (int)1e9;
const int B = (int)sqrt(N * log(N) / log(2));
//const int B = 1;
int n, q, bl[N], br[N], cnt;
PII arr[14][N];
int a[N], posi[14][N];
int index(int x) {
return (x + B - 1) / B;
}
void merge(int depth, int l, int r) {
int mid = (l + r) / 2;
int num = 0;
int h1 = l, h2 = mid + 1, pos = l;
while (h1 <= mid || h2 <= r) {
if (h1 > mid) arr[depth][pos++] = arr[depth + 1][h2++];
else if (h2 > r) {
arr[depth][pos++] = arr[depth + 1][h1++];
arr[depth][pos - 1].fi += num;
}
else {
if (arr[depth + 1][h2].fi <= arr[depth + 1][h1].fi + num) {
arr[depth][pos++] = arr[depth + 1][h2++];
num++;
}
else {
arr[depth][pos++] = arr[depth + 1][h1++];
arr[depth][pos - 1].fi += num;
}
}
}
repn(i, l, r) {
posi[depth][arr[depth][i].se] = arr[depth][i].fi;
}
}
void build(int depth, int l, int r) {
if (l == r) {
arr[depth][l] = mp(a[l], l);
posi[depth][l] = a[l];
return;
}
int mid = (l + r) / 2;
build(depth + 1, l, mid);
build(depth + 1, mid + 1, r);
merge(depth, l, r);
}
void change(int depth, int l, int r, int x) {
if (l == r) {
arr[depth][l] = mp(a[l], l);
posi[depth][l] = a[l];
return;
}
int mid = (l + r) / 2;
if (x <= mid) change(depth + 1, l, mid, x);
else change(depth + 1, mid + 1, r, x);
merge(depth, l, r);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cnt = (n + B - 1) / B;
rep(i, 1, cnt) {
bl[i] = br[i - 1] + 1;
br[i] = bl[i] + B - 1;
}
bl[cnt] = br[cnt - 1] + 1;
br[cnt] = n;
repn(i, 1, n) {
cin >> a[i];
a[i] = i - a[i];
}
repn(i, 1, cnt) {
build(0, bl[i], br[i]);
}
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int x, y;
cin >> x >> y;
a[x] = x - y;
int bid = index(x);
change(0, bl[bid], br[bid], x);
}
else {
int k;
cin >> k;
int bid = index(k);
int cur = posi[0][k];
repn(i, bid + 1, cnt) {
int l = bl[i];
int r = br[i];
int ans;
if (cur < arr[0][l].fi) continue;
while (l <= r) {
int mid = (l + r) / 2, num = mid - bl[i] + 1;
if (cur + num > arr[0][mid].fi) l = mid + 1, ans = mid;
else r = mid - 1;
}
cur = cur + ans - bl[i] + 1;
}
cout << cur << "\n";
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
#define F first
#define S second
const int MOD = 1e9 + 7;//XXX
const int C = 26;//XXX
void add(int &x, int y){
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x){
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b){
int ret = 1;
while (b){
if (b & 1)
ret = 1ll*ret*a%MOD;
b >>= 1;
a = 1ll*a*a%MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
const int SQ = 200;
int n, a[MAXN];
int weed[MAXN<<2];
vector<int> vec[(MAXN + SQ - 1) / SQ]; // +1 for each of these you're >= than
void plant(int v, int b, int e) {
if(e-b == 1) {
weed[v] = b != 0;
return;
}
int m = (b + e) >> 1;
plant(v<<1, b, m);
plant(v<<1^1, m, e);
weed[v] = weed[v<<1] + weed[v<<1^1];
}
void water(int i, int x) {
int v = 1, b = 0, e = n;
while(b < e) {
weed[v] += x;
if(e-b == 1)
break;
int m = (b + e) >> 1;
if(i < m) {
e = m;
v = v<<1;
} else {
b = m;
v = v<<1^1;
}
}
}
int descend(int s) { // first >= s
int v = 1, b = 0, e = n;
while(b < e) {
if(e-b == 1) {
return weed[v] < s ? e : b;
}
int m = (b + e) >> 1;
if(weed[v<<1] < s) {
s -= weed[v<<1];
v = v<<1^1;
b = m;
} else {
v = v<<1;
e = m;
}
}
return -1;
}
void build(int id) {
vec[id].clear();
int l = id * SQ, r = min(n, l + SQ);
for(int i = l; i < r; i++) {
int j = descend(a[i]);
vec[id].push_back(j);
water(j, 1);
}
for(int j : vec[id])
water(j, -1);
sort(vec[id].begin(), vec[id].end());
}
void qry() {
int i; cin >> i; i--;
int ans = a[i];
for(i++; i < n && i % SQ != 0; i++)
if(a[i] <= ans)
++ans;
for(; i < n; i += SQ) {
ans += upper_bound(vec[i / SQ].begin(), vec[i / SQ].end(), ans) - vec[i / SQ].begin();
}
cout << ans+1 << "\n";
}
void solve() {
cin >> n;
for(int i = 0; i < n; i++) {
cin >> a[i];
a[i] = i - a[i];
}
plant(1, 0, n);
for(int l = 0; l < n; l += SQ) {
build(l / SQ);
}
int q; cin >> q;
while(q--) {
int qt; cin >> qt;
if(qt == 1) {
int i, x; cin >> i >> x; --i; x = i - x;
a[i] = x;
build(i / SQ);
} else {
qry();
}
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cout << fixed << setprecision(6);
int te = 1;
//cin >> te;
for (int w = 1; w <= te; w++){
//cout << "Case #" << w << ": ";
solve();
}
return 0;
}
// recursion = shit |
/*
XqQRREXJ7ii:..::::iiiiiirirrv7vvvvsuIXDQBBBDPJ7i:...::r2vrrr7rrr7rvJLuqPXdd22Yrii:.:. .::......... ..........:.....:...:.:.:...:...:...:.:.:...:.:.:.
r:irrLuIIqX52u7i::.......::::::::i:i:::rrvsSKZEgEP2uri.i::.:...::..i::.::r77vUJ1r: . . . . .
i:i:i:i:rrvLSPdZQDEqKjY7i:::::::i:i:iii:iiiiir7YIbMMRgSL7irriijPDKqqKUI15XZPXSEMBQD5uIJ::. ... . ....................................:.......:.:...
:.:::::i:::::iiirvLjIPDgEDPXUu7r::::.::::i:iiiii:::r7UdPKggMDRQBBBBBQBBBBBBBBBBBBBQBBBBM57:: ...................................................
vii::...::::::::::::::iirvj2PdZdDddSuvri::..:::.:r1dRQBBBBBBBBBBBBBQBQBBBQBQBQBBBQBBBBBBBBQgXr. ..............................................
gDDZPKuv7r::::.:.::::::::i:::iir7sjISbPEK2Yvr7YPMBQBBBQBBBBBBBBBBBBBQBBBBBQBQBQQQQRBQBQBBBBBBBdvi: ...........................................
::vLuUqbZEgEb5jvvii:::::::::::::::::iivs5PQQBBBQBBBQQQBQQQBQBQBQBBBQBQBQBBBQBQQQQQBQBBBQBQQQBBBBBMXYv7i. . ........................................
:::::::::r7YY5qZgQDPI5uvrr::.:::::.::7sIbQBBBBBBQBQBQBQBQBBBQBBBBBQBQBQBQBQQQQQBQBQQBBQBQBQQRBQBBBBBBBgIr:. .......................................
:.::::::::::::i:ii7vu2XPggMPP51vr::ivJSEQQBQBQBQBQBQBBBQBQBQBQBQBQBBBBBQBBBQQQBQBQBQBBBQBQBQBQBQBQBQBQBBBggX7. .....................................
7i::.....::::::::::::::iir7YuSXqXXqdZMQBBBQBQBQQQBBBBBBBQBQBQBBBQBQBQBBBQBQBQBQBQBQBQBQBQBQBBBQBQBQQQBQBQBRBBPi. .....................................
ZqgDESIJvrr::.:::.::::::::::::::ivdRBBBQBBBQBQQQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBQBBBQBQBQQQQQQQQRMPKPP7. ...................................
i:i7vU5KSbZZPdSjv7i:.:...:.:::.i7PQBBBQBBBBBQBQBBBQBQBQBQBQBQBBBQBQBQBQBQQQQRQQBQQQQQQQQQBQBBBQBQQQQRQRQRQQBgggI:.....................................
i.::::::::rrvs12PPPbgdXJsri:::vKRBBBBQBQBBBBBQBBBQBQBQBQBQBQBQBQQQQQQRBQBQQRQMQQBQQQQQBQBQBQBQBQBQQRQRBQBQQQBQQdv.....................................
..:::::::::::::::ii77YUqqdbZXEQBQBQBBBQBQBBBBBBBQBQQQBQBQBQBQBQBRQQQMQQBQQQBQQRBQQQQQQMQQQQBQQQBQQRQMQRQMQRQRQBQdr ...................................
si7i::..:.:.::::::::::i:i::i5QBQBQBQBQBQBQBQBBBQBQBQQQBQQQBQQQQQQQQQQQBQBBBBBQBQQQQMMgRgQQBQQQBQQQQMRgQMQRQRQRBQQPi .................................
qPZZddS2jvri::.....::::::::7ZBBBQBQBQBQBQBQBBBQBQBQBBBBBQQRQQQQQQQRQRQRQgMZDDgZgZgEZEZEggMRBQBRQQQMQMQRQMQRQgRRBMqv .................................
:.ri77j5PqEddKP51v7ii::...:1BBBQBQBBBQBBBQBQQQQQBQBQQQBQQRQMBQBRQQQMRggPK555X5SXPPKSPbZZggRMQQQRQQQRQMQMQMQgQMQQQbu. ................................
:.:i:i:::::rrvs22SPEdbqbIvrdBBQQBBBBQBBBQBQBQBQBQBQBQQQBQQgQRQZdMgDgdbSSUIU2u1JUjUssuXPPPZZZKqgRDMRQQQQQRQRQgQMQQBg7 ................................
:.::::::::i:::::::iir7vs11PQBBBQQQBQBQBQBQBQBBBBBQBQQQQMgZggQEX5ZbEdPSSI5IUJuYJj1j1j5XPXqqqI2uPZDEgDRRQQQMQgQgQRQBBd: ...............................
17rr::.:...::::::::::::::isRQBQBQQQBQBQBQBQBQBQBQQQQQQQQdddZdES5IPqqI5U1JusJYYvJ1I5X5SIIu1LvvYY2IqqPbDDggQRMgMgQQQBBv ...............................
K2DDEPPXSJYvr::.:.:.::::i2QBBQBQBQBBBBBQBQBQBQQQBQRgQMQgEqXSKKXJsvsYJsJ77r77vvLvvLJLJsjv77777777YYU2qPEEZDRgRgMgQQQBR: ..............................
:.:ii7LjuXPDPbbP51Jsri::.YQBBBQBBBQBQBQBQBQBBBQBQRgRMgPPKqSIUIUuLJsjYYv77v7v7v7v777777irirr77777r7rYsU5ddDDRMQRRgRQBBI. ..............................
i.i:::::::::ii7vj2SSbERbXqBBBQBQBBBQBQBQBQBBBQBRQRQRQdqXKSKI2uusJLYvv7vrrirrrr77777r7rrrrirr777r7r77Ys15bbEERgRgRMQRBgi .............................
...:::::::::::::::::iri7vLbBQBQBQBQBQBQBQBQBBBQQQQRQgdXX55I52UsJsY7777r7rririrr7r7r7rrv7rrrrrrrrrrr77vL1IqqbEZbRgQMQQBY...............................
Uvsri:::....:.::::::i:::irZQBQBQBQBQBQBQBQBQBQQQQRQQRPPPq555X1uLJLv77r7rrrrr7r7rrrrr7rvrrirrrrrrrr77v7sLjJU5EZEDQQBQQB5..............................
U1KEdDZP55svrri:::.:.::::UgBBBQQQBBBQBQBQBQBRQQBQBQRDgPPKK5SS2uuss7v77r777r7r7r7r7r7r7ri:iiiiiiri7r7vYYjJuLJ2bqbgBQQQBs. .............................
i.i:iir7sUSSEEdqdPKJv7rruRBQBQBQBQBBBBBQBQBQQQQQBQQggZEPbqS22U2uUYv7777r7r7rrr7r7r7r7rrrriiiiirr7777LvJs1jusjuU1dQBQQBj..............................
:.:::::::::::ii77ss2SPqPDQQBQBBBQBQBQBQQQBQQRQRQQQMMZDEDdb5512121s7v777777rrr7r7r7r7rr77rrirr777r7r77L7LLJs1u1YsXQQQQBu..............................
:.::::::::i::::::::::::iYKQQBQBQBQBQQRQMQQQMQRQMQRMDMggPPXXII2511vsYsLYLYvv7777rrr7777777r7r7rrrrirr7r77vvLYuuuY5RQMBBv ..............................
PuYvrri:::...::::::i:i::i1RBBBQQQBQQQQQQQQRRMRgQQBQQgEKS2IU5IS5SuJu5U21uuuvv77rrrrrrr7rrr7r7r7r7rrrrirr77v7vvjssuRQQQBL. .............................
1LqqddEEd5I1j7ri::...::::YMBBQQQQQQQQQQQQRRMQggRQQgPXU2U5I5IXSX5SIKXPPKuvrriiii:iiiii:iirr77777iii:::irr7r7r7vY7uZQRBQ2..............................
:.:::irr7sUKSPPDEPIS2uvr:rIQQBQQQBQQQQQQRQMQRMgQREX2u21I55IXXKSqPPPdbEPXUusuvv77rriiii::...:::.... ..::ir777vUjsvPQRBZi...............................
i.i:i:i:::::i:iirrj2IUXXPUPQBQQQQQBQQRQMQRQMRMQRd5212UI2I5XXqqPdRgMgRMQQBQBQBQDKPuJJLriii.... ...ir7L25PPdXXXdX5XQBB7 .............................
:.:::::::i:i:::::::::::::72QBBQBBBQQQQMMQQRRDQQQqIUIUIU5ISXPqddEKSj1sYY5XPbEPEPPPqS2svr7r7rrii:irvs5SEMBQBQBQMdEPEMBDi ...............................
512vvrii:.::::::::i:i:i:::uBBBBBBQBQQMRgQRRMRRQbX25IX2I255X5X5X1s7ririrr77vvLvYLsYjYL77r7rrrrr7rLYU5XIXqPPDZDEZgQMRBP:...............................
LL15XbddqqSSujYvii::::::::rDQDbDQBBBRQMQRQMQQQMb55ISIS25252UujsYvLY7r7r7rriiir7v7v7Lvvr7rrr7r777vYYjLYvv77r7r7v12EQBv ...............................
i.::::ii77LJ5KdPPqbPKu1J7iv2qKSuUqBBBQQRQRQQBRgPX25I5I512u2j1JsLYvL7rii:::::::irv7v777777rrrrrv7vvs77rriiiir7vY77JBBi ...............................
:.::::::::::::::i7r7vJ1UJSqEEdKquvLdQBBBQQRQQMdP55IS252511suYJvv777LssLjjUujYr:i7Yvvrrri:iirrvYJsJvr::...::irYYY7sBM. ................................
:.:.:.::::::i:::::i::::::YdEq221I1v71XdRBQQQBDZXS5SIIISIIJjsJs1u25bgBBBBBBBKgQZY7vuvrrr:::i:7vYs1vriYXEPSIULrr77vsB7 ...............................
b5U1jvii::::.:.::::::i::iUqKIXUYvjUJ7v1PZBQBMgqX5X5SI52S11LYvYjXPdEdPQBBBBq..7QB2r7vrrrririrrLLJ7vqBQBBBRsKBQbY77sgi .................................
L7U5PqPEMEbS51uv7ri::.:.rSP2UXjiirs2jYUUKRBMgbK5K5X5X252IJJv7777YLvvYvvJKUv7jjSbXirr7rv77rrrY1jiiSRBBBBBP.:1QBDj7vQL.................................
:.:::::rirrJJ22KPZPPqEKUUqK12XvrrsvS51USIMRdKPKKSX5S5SIXUUJYvLvv77777rrrrrrv77rii7rv7vvL7777vSqLrYY1XEPPIU1UU2I2LLbi .................................
:.i:::::::::::::iiir7vsY1XPU5YYuIKgMb5PSKDQdbXX5X5XISUI1Ussvvvsvv77777v777L777rirr7vv7YLvvL77YSJ7irrrr7rr777rrvvsY5: .................................
:..:...::::::i:i:::::::::1SIYJ1KPEX7jqXKKMMZKX5S5SISI2u2jJYY777v777v77r7r777rrrrrrrv7LYLLYvLvssY77r7rrr77v77777v7Yui .................................
bUqUsvLri::::::...:::::::rI2Yjq52Yriuj1UKgQbK5K5SIIUIuUU1ss77r77v7v7v777777r7r7rrr77vYJYJLLLsLY7v77rrirrrrrr7777vvJr.................................
7rLJuqbPSKqPIU1UsLrrii::..r2sIKXvrrsYvuSqMgdIS55I51U111UssLLrrirr77777777777r7r7rrrvvJuuJYvsvsLYvv7777r7r777777v7vLJ: ................................
:.::::::iirr77u2K5XXPPPSq55SSsSqvivLJvjSbEdKSIXS5II1Uj1jjLsv7rrrrrrr7r77vr7r7rriiivs1uU1UYvvYvsYJvv777v77777777777LJr................................
:.:::::::::::::::::iirrYJJv2P2YuuUKX12Y5PEPP5XXX5S1Ujuj1ssLYvv7rirr777r7r7riii::iL5K55U2jL7v777sJjriirirr7r7777v77vJr.................................
i.:.......::::i:i:::i::::::rKdK2UuUIKX22bKPSKXK5XIIuUj1jjsjLYL7iiirr7rriiii:i::72SXu1ujv7:.::..rsJr:i:iir7777r77v7LY7.................................
DqPq21svrri::....:.:::::::::rqKXIU77vJJXqqXqXqSX5S2I11J1JuJusY77rr:.:iirii:iirLKX1svriirr7iir::irLY7iiii:ir7777v7vvjr.................................
risY1IKPgMMPPPP2UJj7rii::....i5II1j7v7JUPPPqqSK5S5X2UJUu21Uj1Lv7vri.::rrr:iirLPXXjs77sPKXUYrrr7LsvLJvir:::irr777v7Lur................................
:.:::::::iirrYLu1SPbPdEgZP5IsvL5SUsuvvrv5bKqPqXXISI5U2UUuUjujL7L7rii:irriiiriY1UXP5KDBBBggbPSKRBBIJSLirrr::rir7v7LYs:.................................
:.::::::::::::::::::iiri77JjIUjuKPPSUYvYbdbPPXK5S5SIS2Uu1suJ1LY77rr:ir7rr:iiiiir7vIX2YYuI2PPXuPDZ52Lrirrriii7777vv1r.................................
:..:.......:.::::::::::::::::::::7jKPZERQQbbKK5S2II52IU2uuJjJYvL77riiririririiiri77s7vvUI7irirvY77rriiirii:rr77v7Js: .................................
DKEX2JJYYrri:::.:...:::::::::::::::.7gBgd2PdPKXIS252S2IUIuuJ1sLvvrrii:irrirrrr7rvYJYYYs7r77r77UusvL7riiiiiirr777LJr ..................................
ri7LLUUXXqPDEbI52UJYrrri::::::::::.:.IDSYs5EPPXXSSU5UI12UUuUJJLY77rriii7rrrr7v7L7YvYsusLvYvLvvJU1UJuvvirirr7r77LYY. ...................:..............
i.i:::::iii:rr7vJjIIIXdPqSqqP2Jvs77i:7DSUsIbDdPSS25UUU2UUu1JuJJ7vrrri:rrrrv7vr7777v777vrrr77vi7vsYjJ1Y7irrr7v7vv1r ...............:::::::::::.:::....
...::::::i:i:i:::::::::ii7rvvLs2Sq552XEP221dDZPXIIII1U1Uj1JjJ1Jv7rrriiirrLYv77rri7rrr77YsJYjLLvLvLvsLs7777r77v7JY:.:...:.::::::::::i:::::::::::::::::.
Jrrrr::::::::.::::::::i:i:i:i:i:::iiiijdKIIKZEdqK25U212U2UUuuYJvvrriririrv1u1JsjKqbEMRRgRDgZDDgEPU177LYLL77777Yu7.::::::::::::::::iiiiiiriiiiii:::i::.
SXZRgDPEbZq5uuLvrri:::.:.::::::::::i::7dqX2qdEbPqXI5UU1Uj2u1J1ss7777irr7sPZMgMgRDDddqX2I1IU21XPggDgDX2LLvv7777uI:::i:i:iiiii:iiiiiirr77v7v77r7rrrrii::
i.iiiir7YLu1XPDDRZDdRDEKX221J77rii:::.:uESS5dEDbPXK221U1UjUuIuJLv7L7rrvjX1JJUUX5K5XUJrrrririii7vuIPPZbKsvvv7vvSviirr7rrrrrrr7r7777v7LvYvLvLvvvL7v77rr:
:.:::::::::::::::iir7LL12XPZdDgRgRgZPbSDdPSKKEZEPPqK5S252I12uUJ1Y7r777vjv77v7LYjJ111Jvr7r7rrrr7Ys1Lssuus777vvIJri7r7777v7v7v7vvLvvvv7v7vvvvY7v7vvLvL7r
:.::::::::::::::::::i:i::::::iiir7LYU2UIgPPSXPZEZbdbPKXIS25UUu21uv7r7r7777v7vvsLYvYsUu2u1j1suYujuLsvv7L77777j2virr7r7r77v7v7v7vvLvv7v7v7vvvvL7YvLvLLY7
riii::.:.:::.::::::::::::::::i:iii:::i:iPDKXSXqZEdddqPKK5SI52I1IUjvvrrr7r77vvYvYLYvLvJJU1I1UjuYjLLLY7v777v7L1virr77777777v7v7v7v7v7v7v7v7v7vvLvYvLvLvv
ZqZPPKqqKu1Lv7rii:::....::::i:i:iiiii:::SZq5KSPPDEZPPqqKKS5ISIIUI11v7rrr77LYJLsYsLsvv77r77L7v777vLYvY7v7vvuuYirr7777v7v777v7v7v7v7v7vvv7LvLvvvLvv7LvY7
i:irrvsJY2IPdgZZPbEdIUJ1uj77rr:i::::::::JDXKXKSPbDgDbEPPKq5S55U51I1uv7r77v7LYJYJvYLsvv7v7v7v7vvYvYsJYY7vvjULirr77777777v7v7v7v7v7v7v7v7vvvvL7LvvvvvYv7
i.i:::::i:::::i:rrvLJj5XPKPPdbdqPS5IIUYrIZPKXIX5SKZEDEEddPbXq5SUI1IU1v7rrrrrvLsvYvsLsvLvv7Y777YYsYJYLvYLUUsrrr7r7r777777v77777v7v7v7v7vvLvvvvvvvYvLvL7
:.:i:i:i:i:::::::::::::::::iirr7rvJ22KXPPDPKSX5XI5KDDgZDdEPPPPX5U1jU1uv7irirrv777LLLvYvLvLvvrvvJLJvsvvYU2Yrrr7r7r7777777777v777v7v7vvv7Lvvvv7L7vvLvLv7
7:r:::::::::::::::::::::iii:::i:i:i:::i:7dEKX5X5X5X5bEMggdZPbPP5522uU1Uvv77rrrrrr7YvLL1U1vvY1JujjLLvLvJuvrrrrr7r7r7r777777v7v7v7v7v7vvvvLvLvLvL7L7vLY7
X5ZMgdSSI521sL77rri::::::::::::i:i:i:i::rdPqSK5SISI52IXggRggbPPPSK5SI522u1YL7777rvsuJUU5UUjSSIJ1ujvLvjuLirr7r7r7r7r777r77v7v7v7v7v7vvYvLvLvLvLvv7L7YL7
i.iirr77J121IIPPgDbKPqPXIsYvLv77rii::::.rPbXXIS25252S1U1qZQMREEPPPPPbqqXPS2sJvLvJj2UIISI52S5XU1JuYJsI5srrrrr7r7r77v77777v7v7v7v7v7vvvvvvvvLvvvvvvvLvs7
:.:::::::::::::::ir7vJsuuuuPPPXPqPZgPq1YugbPKKSXIS55I51UjU5PZQQRDDPdPdPqKP55U2uUjjsU15XqIX5qSPS1J1USXJrrr7r7r777r77v777v7v7v7v7v7v7v7vvLLvvv7L7L7v7YL7
:.::i:::::::i:::::::::::i:::::iirr77vYus5DdKPXKSqSSI5UI1UuuJ15EMBQQgZbbPbPdPbqKIIjuu12K5XSqSPPqISXdKLirr7r7r7r77v7v7v7v7v7v7v7v7v7vvL7LvY7vvLvYvLvLvY7
rirr:::::::::::::::::::::iii:iii:i:i:i::rEPPXKSKXS5522u2UIuujUuI5ZRBBQgZPddEPdPPSKSK5XSSISSXXPPPPbqJirrrr7r7r7777777777v7v7v7v7v7vvvvLvLLvvLvvvYvYvYvv
ZKPSKbdPP11uJYL7r:i:::::::::::i:i:i:ii::UDdXPKKSqIX5IU212j1u2UUJu1UXDRBQBMMDZEZbZdEPdKKSXXKXbZDdb55vrrrr7r7r7r7777v7v7v7v7v7v7v7v7v7v7Lvv7LvL7LvLvYvL7
i:iri77vLssU2PXX5KPEPP5SI5I5jv77rriiii:iPgPPqPKqKKSS2I1Uu1uU12122I1UjUKMBBBBBQRRggDgDggMgMZgdZKXI5Ijirr7r7r7r777777v7v7v7v7v7v7vvLvvvLvL7v7LvLvLvYvYLv
i.i:i:::::::::::iirrrr77suSIXISXPXqSSI25DdbPqKKXPSSI5UU12uUu22I2S2S2S1uY1IERBBBBBBBQBQRdPS52I25252SJrr7r7r7777v777v7v7v7v7v7vvvvv7LvL7vvLvLvvvLvYvYLY7
:.:i:iii:i:i:::i:::::i:i:i:i:iiii::rir5MdEPbKKXXXq5SU5221IU2121IUI2X5SIX5515KERBQBQQEPIU1IU52S2S22S2rrr7r7r777777v7v7v7v7v7v7LvLvv7v7v7L7L7LvLvYLYvYvv
siririiii::::::::::::iiiiiiiiii.::i..YgZbbbPPqqXK5X5X5X222IU52S2IISSqXPqbdEPPXSIS552S2SKPqPKKXX5SIKU7i7r7777v777v7v7v7v7vvvvLvv7LvvvvvL7L7vvLvLvLvLLY7
SIPdddXXXKSX21Ysv777irii:i::::.rIMBd2DbZPdPPqPXKSX5X5IuUjuYjJuJjsusuu1jUJjYJYJJJJ1122IU52I252I2SU5I57rr77777777v777v7vvvvvvYvvvL7L7L7LvL7Lvvvv7LvLvLL7
i.iiiirr77LvJjIIqqdPPXPKP1sLv75QBBBBQgZPPqPKqXK5SU212uuJjvYvL7vvv7vr7r7777vvYvsLjJ1sJsuu1ssYJsjj11I2sirr7r777777v777L7v7LvLvLvvvvvLvvvLvL7vvYvLvLvYvs7
i::i:::i:::i:i:::::i:iiri7ZQgBBQgRMQQQRRgMDdqK52jjsJLujussLYvv7v7v7v7v7v7vvLLYLsvsYssJYuJJsuJujuJUUS17irr7777v777v7v7L7LvvvLvYvLvvvv7LvLvLvvvYvYvYvYLL
i.::::::i:i:i:::i:i::....vBBBBQMRggDggQQBQBQQgMDDPX2jvvr7777vvv7v7v7v7v7v7v7vvLvv7LLYLJjusuJujuJ11215usriirrr77777vvv7v7vvLvv7vvL7vvv7vvL7v7vvYvYvLvL7
Yrrrrrii::::::::.:.::rsKPQRQQQQQQQMQgMZgDRgQQBQBQBBBQREdS2v7rrr77vvvvY7v7v7vvLvvvv7v7vvLvvvsvuJ1uU2IUSQBZKvriirrr77vvv7LvLvvvYvYvL7v7LvvvLvL7vvLLYvLv7
KIqSSXbqS1Jvv7777vuKRQBQBRgZMDMgRQBQBBBQBQBRQRRgQMQMQBBQBBBMgq2s7r7r7vLvvvLvv777v77777v7v7vvssjJ11UU2uqBBBQZPUuv7rr7v7vvY7LvLvYvLvLvv7LvLvvvvvYvYvYvY7
...:.ii7vIKgMRQBQBQQRMZgDMDgDgDgZgDggRMQRQQQQBQQQQRQMMgggMMBBBBBgPI1v7r7vsvLvv77r7rv7v7v7LvJYjjujUu2UUsPQBBBBQgRP1rrrrr7777v7v7v7LvLvLvvvYLYvYvLLYvsLv
v71UqbEZggggRgMggZgZDdZdZEggggMggggDggMgggMgRMRMQMQQQQBRRgRgRRQQBBBQMq5Yv7vvYvv77r7r77vvvvYYssjsuj1u2U2YSQBQQEZgQgES2sv77rrrrr777vvvLvYvLvsvYvsvsLsYY7
BRQQMgEEPdPbPEPdPZdEdDDgEZZgEDDggMgMgggMggDgZgDMgRggggDMgMgRgMggZMgRQBBQEKuYvv77iriiirrrrrr7r77v7vvYLsYLvIIPPddZbDgQgMDgDZPPS5jJvL7v7777r7r7r7r7r7r77r
*/
#include<bits/stdc++.h>
#define LL long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
using namespace std;
namespace IO
{
const int sz=1<<15;
char inbuf[sz],outbuf[sz];
char *pinbuf=inbuf+sz;
char *poutbuf=outbuf;
inline char _getchar()
{
if (pinbuf==inbuf+sz)fread(inbuf,1,sz,stdin),pinbuf=inbuf;
return *(pinbuf++);
}
inline void _putchar(char x)
{
if (poutbuf==outbuf+sz)fwrite(outbuf,1,sz,stdout),poutbuf=outbuf;
*(poutbuf++)=x;
}
inline void flush()
{
if (poutbuf!=outbuf)fwrite(outbuf,1,poutbuf-outbuf,stdout),poutbuf=outbuf;
}
}
inline int read(){
int v=0,f=1;
char c=getchar();
while (c<'0' || c>'9'){
if (c=='-') f=-1;
c=getchar();
}
while (c>='0' && c<='9'){
v=v*10+c-'0';
c=getchar();
}
return v*f;
}
const int Maxn=100005;
const int B=605;
int n,b[Maxn],N,q;
struct Segtree{
int L,R;
vector<int> Ord[B*4],Pos[B*4];
void Pull(int p){
Ord[p].clear();Pos[p].clear();
int j=0,Cp=Pos[p*2][0];
for (int i=0;i<Ord[p*2].size();i++){
//cerr<<"FK"<<Pos[p*2+1][j]<<' '<<Cp<<endl;
while (j<Ord[p*2+1].size() && Pos[p*2+1][j]<=Cp){
Ord[p].pb(Ord[p*2+1][j]);Pos[p].pb(Pos[p*2+1][j]);
Cp++;j++;
}
//cerr<<"FKKKK"<<i<<" "<<Cp<<endl;
Pos[p].pb(Cp);Ord[p].pb(Ord[p*2][i]);
if (i!=Ord[p*2].size()-1){
Cp+=Pos[p*2][i+1]-Pos[p*2][i];
}
}
while (j<Ord[p*2+1].size()){
Ord[p].pb(Ord[p*2+1][j]);Pos[p].pb(Pos[p*2+1][j]);
j++;
}
}
void build(int p,int l,int r){
if (l==r){
Ord[p].pb(l);
Pos[p].pb(b[l]);
//cerr<<"FK"<<l<<' '<<b[l]<<endl;
return;
}
int mid=l+r>>1;
build(p*2,l,mid);
build(p*2+1,mid+1,r);
Pull(p);
/*cerr<<"DEBUG"<<l<<' '<<r<<endl;
for (int i=0;i<Ord[p].size();i++){
cout<<Ord[p][i]<<' '<<Pos[p][i]<<endl;
}*/
}
void modify(int p,int l,int r,int pos){
if (l==r){
Pos[p][0]=b[l];
return;
}
int mid=l+r>>1;
if (pos<=mid){
modify(p*2,l,mid,pos);
}
else{
modify(p*2+1,mid+1,r,pos);
}
Pull(p);
}
void build(){
build(1,L,R);
}
void modify(int pos){
modify(1,L,R,pos);
}
}T[305];
int main(){
n=read();
for (int i=1;i<=n;i++) b[i]=read();
for (int i=1;i<=n;i++) b[i]=i-b[i];
q=read();
N=(n-1)/B;
for (int i=0;i<=N;i++){
T[i].L=i*B+1;
T[i].R=min(n,T[i].L+B-1);
T[i].build();
}
while (q--){
int tp=read();
if (tp==1){
int i,x;
i=read();x=read();
b[i]=i-x;
int I=(i-1)/B;
T[I].modify(i);
}else{
int i=read();
int I=(i-1)/B;
int ans=0;
for (int j=0;j<T[I].Ord[1].size();j++){
if (T[I].Ord[1][j]==i) ans=T[I].Pos[1][j];
}
for (int j=I+1;j<=N;j++){
int lo=-1,hi=T[j].Pos[1].size();
while (hi-lo>1){
int mid=lo+hi>>1;
if (ans+mid+1>T[j].Pos[1][mid]) lo=mid;
else hi=mid;
}
ans+=lo+1;
}
printf("%d\n",ans);
}
}
}
/*
3
0 1 0
7
2 1
2 2
2 3
1 2 1
2 1
2 2
2 3
*/
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int MAXN=100100;
int n;
int b[MAXN],l[MAXN],r[MAXN],pos[MAXN],tr[MAXN];
vector<int> v[MAXN];
void add(int x,int d)
{
while(x<=n)
{
tr[x]+=d;
x+=x&(-x);
}
}
int find(int x)
{
int ret=0;
for(int i=17;i>=0;i--)
{
if(ret+(1<<i)<n&&tr[ret+(1<<i)]+(1<<i)<x)
{
ret+=1<<i;
x-=tr[ret]+(1<<i);
}
}
return ret+1;
}
void build(int x)
{
v[x].clear();
for(int i=l[x];i<=r[x];i++)
{
int p=find(b[i]+1)-1;
v[x].push_back(p);
add(p+1,1);
}
for(int i=0;i<v[x].size();i++)
add(v[x][i]+1,-1);
sort(v[x].begin(),v[x].end());
}
int main()
{
int i,j,len,blocks,q,op,x,y,ans;
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d",&b[i]);
len=min(n,200);
blocks=n/len;
if(n%len)
blocks++;
for(i=1;i<=blocks;i++)
{
l[i]=(i-1)*len+1;
r[i]=min(n,i*len);
for(j=l[i];j<=r[i];j++)
pos[j]=i;
}
for(i=1;i<=blocks;i++)
build(i);
scanf("%d",&q);
while(q--)
{
scanf("%d",&op);
if(op==1)
{
scanf("%d%d",&x,&y);
b[x]=y;
build(pos[x]);
}
else
{
scanf("%d",&x);
ans=b[x];
for(i=x+1;i<=r[pos[x]];i++)
ans+=b[i]<=ans;
for(i=pos[x]+1;i<=blocks;i++)
ans+=upper_bound(v[i].begin(),v[i].end(),ans)-v[i].begin();
printf("%d\n",n-ans);
}
}
}
|
#include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) cout<<i<<" ";puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
const int N = 1e5+10, M = 1010;
int n,q,B,a[N],id[N],cnt[M];
int b[M],tag[M<<2];
pa mn[M<<2];
inline void Build(int u,int l,int r){
tag[u]=0;
if (l==r) return mn[u]=mp(b[l],l),void(0);
int mid=l+r>>1;
Build(u<<1,l,mid),Build(u<<1^1,mid+1,r);
mn[u]=min(mn[u<<1],mn[u<<1^1]);
}
inline void update(int u,int l,int r,int ql){
if (l>ql) return tag[u]--,mn[u].fi--,void(0);
if (l==r) return mn[u]=mp(1e9,l),void(0);
int mid=l+r>>1;
update(u<<1^1,mid+1,r,ql);
if (ql<=mid) update(u<<1,l,mid,ql);
mn[u]=min(mn[u<<1],mn[u<<1^1]),mn[u].fi+=tag[u];
}
int v[M][M];
inline void ReBuild(int id){
int l=(id-1)*B+1,r=min(id*B,n),cnt=0;
For(i,l,r) b[++cnt]=a[i];
Build(1,1,cnt);
For(i,1,cnt){
int tmp=mn[1].fi;
v[id][i]=max(tmp,v[id][i-1]),update(1,1,cnt,mn[1].se);
}
}
inline int Query(int x){
int y=a[x];
For(i,x+1,min(id[x]*B,n)) y+=(y>=a[i]);
For(i,id[x]+1,id[n]){
int tmp=upper_bound(v[i]+1,v[i]+cnt[i]+1,y)-v[i]-1;
y+=tmp;
}
return n-y;
}
int main(){
n=read(),B=200;
For(i,1,n) a[i]=read(),id[i]=(i-1)/B+1,cnt[id[i]]++;
For(i,1,id[n]) ReBuild(i);
q=read();
while (q--){
int op=read(),x=read();
if (op==1){
int y=read();
a[x]=y,ReBuild(id[x]);
} else {
printf("%d\n",Query(x));
}
}
} |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cctype>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <ctime>
#include <cassert>
#define _for(i,a,b) for(int i=(a);i<(b);++i)
#define _rep(i,a,b) for(int i=(a);i<=(b);++i)
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
inline int read_int(){
int t=0;bool sign=false;char c=getchar();
while(!isdigit(c)){sign|=c=='-';c=getchar();}
while(isdigit(c)){t=(t<<1)+(t<<3)+(c&15);c=getchar();}
return sign?-t:t;
}
inline LL read_LL(){
LL t=0;bool sign=false;char c=getchar();
while(!isdigit(c)){sign|=c=='-';c=getchar();}
while(isdigit(c)){t=(t<<1)+(t<<3)+(c&15);c=getchar();}
return sign?-t:t;
}
inline char get_char(){
char c=getchar();
while(c==' '||c=='\n'||c=='\r')c=getchar();
return c;
}
inline void write(LL x){
register char c[21],len=0;
if(!x)return putchar('0'),void();
if(x<0)x=-x,putchar('-');
while(x)c[++len]=x%10,x/=10;
while(len)putchar(c[len--]+48);
}
inline void space(LL x){write(x),putchar(' ');}
inline void enter(LL x){write(x),putchar('\n');}
const int MAXN=1e5+5;
#define lowbit(x) ((x)&(-x))
int c[MAXN];
void add(int pos,int v){
while(pos<MAXN){
c[pos]+=v;
pos+=lowbit(pos);
}
}
int query(int b){
int pos=0,curb=0;
for(int i=16;i>=0;i--){
if(pos+(1<<i)<MAXN&&c[pos+(1<<i)]+(1<<i)+curb<b){
curb+=c[pos+(1<<i)]+(1<<i);
pos+=(1<<i);
}
}
return pos+1;
}
int b[MAXN],lef[MAXN],rig[MAXN],blk_id[MAXN];
vector<int> a[MAXN];
void build(int k){
a[k].clear();
_rep(i,lef[k],rig[k]){
int t=query(b[i]+1)-1;
a[k].push_back(t);
add(t+1,1);
}
sort(a[k].begin(),a[k].end());
_for(i,0,a[k].size())
add(a[k][i]+1,-1);
}
int main()
{
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
int n=read_int(),blk_sz=sqrt(n/2)+1,m=n/blk_sz;
if(n%blk_sz)m++;
_rep(i,1,n)b[i]=read_int();
_for(i,0,m){
lef[i]=i*blk_sz+1;
rig[i]=min((i+1)*blk_sz,n);
_rep(j,lef[i],rig[i])
blk_id[j]=i;
build(i);
}
int q=read_int();
while(q--){
int opt=read_int(),x=read_int();
if(opt==1){
b[x]=read_int();
build(blk_id[x]);
}
else{
int ans=b[x];
_rep(i,x+1,rig[blk_id[x]]){
if(ans>=b[i])
ans++;
}
_for(i,blk_id[x]+1,m)
ans+=upper_bound(a[i].begin(),a[i].end(),ans)-a[i].begin();
enter(n-ans);
}
}
return 0;
}
|
// wygzgyw
#include <bits/stdc++.h>
using namespace std;
template <typename T> void read(T &t) {
t=0; char ch=getchar(); int f=1;
while (ch<'0'||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
do { (t*=10)+=ch-'0'; ch=getchar(); } while ('0'<=ch&&ch<='9'); t*=f;
}
template <typename T> void write(T t) {
if (t<0) { putchar('-'); write(-t); return; }
if (t>9) write(t/10);
putchar('0'+t%10);
}
template <typename T> void writeln(T t) { write(t); puts(""); }
#define MP make_pair
const int maxn=(1e5)+10;
const int INF=1e9;
const int block=200;
int n,tot,bel[maxn],b[maxn],q;
namespace xyr {
int tr[maxn];
void add(int x,int delta) {
for (;x<=n;x+=x&(-x)) tr[x]+=delta;
}
int Find(int x) {
int res=0,sum=0;
for (int i=17;i>=0;i--)
if (res+(1<<i)<=n&&sum+tr[res+(1<<i)]<x) res+=(1<<i),sum+=tr[res];
return res+1;
}
int query(int x) {
int res=0; for (;x;x-=x&(-x)) res+=tr[x]; return res;
}
};
struct Block {
int l,r,cnt;
int A[block+10],B[block+10];
vector<int> d;
void init() {
cnt=0; d.clear();
for (int i=l;i<=r;i++) {
if (xyr::query(n)<b[i]) continue;
int x=xyr::Find(b[i]);
d.push_back(x);
xyr::add(x,1);
}
sort(d.begin(),d.end());
int rem=0;
for (int i=0;i<d.size();i++) {
rem++;
if (i==(int)d.size()-1||d[i]!=d[i+1]) A[++cnt]=d[i],B[cnt]=rem;
}
for (int x : d) xyr::add(x,-1);
}
int query(int now) {
int pos=upper_bound(A+1,A+cnt+1,now)-A-1;
return now+B[pos];
}
} st[maxn/block+5];
int main() {
//freopen("1.txt","r",stdin);
read(n);
for (int i=1;i<=n;i++) read(b[i]),b[i]=i-b[i];
for (int i=1;i<=n;i++) xyr::add(i,1);
for (int l=1,r;l<=n;l=r+1) {
r=min(n,l+block-1);
tot++; st[tot].l=l,st[tot].r=r;
for (int i=l;i<=r;i++) bel[i]=tot;
st[tot].init();
} read(q);
int op,x;
while (q--) {
read(op),read(x);
if (op==1) {
read(b[x]),b[x]=x-b[x];
st[bel[x]].init();
} else {
int now=b[x];
//for (int i=1;i<=n;i++) printf("%d ",b[i]); puts("");
for (int i=x+1;i<=st[bel[x]].r;i++) {
if (now>=b[i]) now++;
}
//printf("now=%d\n",now);
for (int i=bel[x]+1;i<=tot;i++) {
now=st[i].query(now);
//printf("now=%d\n",now);
}
printf("%d\n",now);
}
}
return 0;
}
/*
0. Enough array size? Enough array size? Enough array size? Integer overflow?
1. Think TWICE, Code ONCE!
Are there any counterexamples to your algo?
2. Be careful about the BOUNDARIES!
N=1? P=1? Something about 0?
3. Do not make STUPID MISTAKES!
Time complexity? Memory usage? Precision error?
*/ |
#include<bits/stdc++.h>
using namespace std;
const int maxn=100005;
const int mlog=18;
const int B=150;
const int S=maxn/B+5;
int n,q,m;
int a[maxn],p[maxn],c[maxn],bl[S],br[S],bu[maxn];
namespace Fenwick{
int t[maxn];
void add(int v,int val){
for(;v<=n;v+=(v&-v))
t[v]+=val;
}
int qry(int k){
int res=0;
for(int i=mlog-1;i>=0;i--){
int cur=res+(1<<i);
if(cur<=n&&(1<<i)-t[cur]<k)
k-=(1<<i)-t[cur],res=cur;
}
res++;
return res;
}
}
void update(int id){
for(int i=br[id];i>=bl[id];i--){
p[i]=Fenwick::qry(a[i]);
Fenwick::add(p[i],1);
}
for(int i=bl[id];i<=br[id];i++)
Fenwick::add(p[i],-1),c[i]=p[i];
sort(c+bl[id],c+br[id]+1);
}
int query(int id,int k){
int l=bl[id]-1,r=br[id];
while(l<r){
int mid=l+r+1>>1;
if(c[mid]-(mid-bl[id]+1)<k)l=mid;
else r=mid-1;
}
return k+l-bl[id]+1;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]),a[i]=i-a[i];
for(int i=1;i<=n;i+=B){
m++;
bl[m]=i;
br[m]=min(n,i+B-1);
for(int j=bl[m];j<=br[m];j++)bu[j]=m;
update(m);
}
scanf("%d",&q);
while(q--){
int op,i;
scanf("%d%d",&op,&i);
if(op==1){
int x;
scanf("%d",&x);
a[i]=i-x;
update(bu[i]);
}
else{
int ans=p[i];
for(int j=bu[i]+1;j<=m;j++)
ans=query(j,ans);
printf("%d\n",ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define range(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ar array
using namespace std;
typedef long long ll;
typedef double ld;
typedef unsigned long long ull;
const ll INF = 2e18;
const int INFi = 2e9 + 5;
const int maxN = 1e5 + 1;
const int md = 1e9 + 7;
const int K = 300;
int n;
int b[maxN];
int bl[maxN];
struct fenwick {
int n{};
vector<int> fenw{};
void build(int k) {
n = k;
fenw.resize(n);
}
void upd(int i, int x) {
for (; i < n; i = i | (i + 1)) fenw[i] += x;
}
int get(int i) {
int res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) res += fenw[i];
return res;
}
int get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
void clear(vector<int> &was) {
for(auto &x : was) {
upd(x, -1);
}
}
} F;
// K log N
void rebuild(int block) {
int l = block * K;
int r = min(l + K, n);
vector<int> res;
for(int i = l; i < r; ++i) {
if (res.empty()) {
res.push_back(b[i]);
F.upd(b[i], 1);
continue;
}
int cur = -1;
int ad = 0;
for(int j = 18; j >= 0; --j) {
int t = 1 << j;
if (cur + t < n && cur + t + F.fenw[cur + t] + ad < b[i]) {
cur += t;
ad += F.fenw[cur];
}
}
cur++;
res.push_back(cur);
F.upd(cur, 1);
}
F.clear(res);
sort(all(res));
for(int i = l; i < r; ++i) {
bl[i] = res[i - l];
}
}
void upd(int i, int x) {
b[i] = x;
b[i] = i - b[i];
rebuild(i / K);
}
// N / K log N
int get(int i) {
int bq = i / K;
int r = min((bq + 1) * K, n);
int to = b[i];
for(int j = i + 1; j < r; ++j) {
if (b[j] <= to) to++;
}
int l = bq * K;
for(int j = bq + 1; j * K < n; ++j) {
r += K;
l += K;
if (r > n) r = n;
int c = (int)(upper_bound(bl + l, bl + r, to) - (bl + l));
to += c;
}
return to;
}
void solve() {
cin >> n;
F.build(n + 5);
range(i, n) {
cin >> b[i];
b[i] = i - b[i];
}
for(int j = 0; j * K < n; ++j) {
rebuild(j);
}
int q; cin >> q;
range(_, q) {
int t; cin >> t;
if (t == 1) {
int i, x; cin >> i >> x;
i--;
upd(i, x);
} else {
int i; cin >> i;
i--;
cout << get(i) + 1 << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
// cout << setprecision(15) << fixed;
int tests = 1;
// cin >> tests;
range(_, tests) {
solve();
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define sz(a) (int)a.size()
#define ll long long
const int mod = 1e9 + 7;
const int N = 320 * 320;
int n, q;
int b[N];
const int MX = 1e5 + 5;
struct BIT{
int bit[N];
void upd(int pos, int v)
{
for(;pos <= N; pos += pos&-pos)
{
bit[pos] += v;
}
}
int firstAtLeast(int x)
{
int pos = 0;
for(int dif = (1 << 16); dif; dif /= 2)
{
if(pos + dif <= N && bit[pos + dif] < x)
{
x -= bit[pos += dif];
}
}
return pos + 1;
}
};
const int BLOCK = 200;
vector <int> incr[N];
int point_upd[N / BLOCK + 10][N];
int range_upd[N / BLOCK + 10][320];
BIT bit;
int query_block(int x, int v)
{
return point_upd[x][v] + range_upd[x][v / 320];
}
void upd_suf(int x, int pos, int delta)
{
for(;pos % 320 != 0; ++pos)
{
point_upd[x][pos] += delta;
}
pos /= 320;
for(;pos < 320; ++pos)
{
range_upd[x][pos] += delta;
}
}
void rebuild_block(int x)
{
int L = BLOCK * (x - 1) + 1;
int R = min(n, BLOCK * x);
if(!sz(incr[x]))
{
incr[x] = vector <int> (R - L + 1, n + 1);
}
int bad = 0;
for(int i = L; i <= R; i++)
{
int ind = bit.firstAtLeast(b[i]);
bit.upd(ind, 1);
int old_val = incr[x][i - L];
incr[x][i - L] = ind;
if(old_val == ind)
{
continue;
}
if(ind + 1 == old_val)
{
++point_upd[x][ind];
}
else if(ind - 1 == old_val)
{
--point_upd[x][old_val];
}
else
{
++bad;
upd_suf(x, old_val, -1);
upd_suf(x, ind, 1);
}
}
for(int i : incr[x])
{
bit.upd(i, -1);
}
}
signed main()
{
// ios_base::sync_with_stdio(0);
// cin.tie(0);
// cout.tie(0);
cin >> n;
for(int i = 1; i <= n; i++)
{
cin >> b[i];
b[i] = i - b[i];
}
for(int i = 1; i <= N; i++)
{
bit.upd(i, 1);
}
for(int i = 1; BLOCK * (i - 1) + 1 <= n; i++)
{
rebuild_block(i);
}
cin >> q;
while(q--)
{
int t;
cin >> t;
if(t == 1)
{
int pos, x;
cin >> pos >> x;
b[pos] = pos - x;
rebuild_block((pos + BLOCK - 1) / BLOCK);
}
else
{
int pos;
cin >> pos;
int cur = b[pos];
while(pos < n && pos % BLOCK != 0)
{
cur += b[++pos] <= cur;
}
while(pos < n)
{
int block = pos / BLOCK + 1;
cur += query_block(block, cur);
pos += BLOCK;
}
cout << cur << "\n";
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define forg(i,x) for(register int i=fir[x];i;i=nxt[i])
#define uu unsigned
#define scanf a14=scanf
#define rint register int
#define fre(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout)
typedef long long ll;
typedef uu long long ull;
typedef pair<int,int>pii;
int a14;
inline int rd(int l,int r){return rand()%(r-l+1)+l;}
const int mxn=1e5+3,sq=200,qs=320;
int n,b[mxn],lp[mxn],rp[mxn],kn,be[mxn],po[mxn],qn;
int ju[mxn/sq+2][mxn],ad[mxn/sq+2][mxn/qs+1];
int TG;
struct shu{
int a[mxn],tg[mxn];
void add(int x){for(;x<=n;x+=x&-x){if(tg[x]!=TG)tg[x]=TG,a[x]=0;++a[x];}}
int ask(int x){
int su=0,p=0;
for(int i=1<<16;i;i>>=1){
if(p+i>=n)continue;
p+=i;if(tg[p]!=TG)tg[p]=TG,a[p]=0;
if(p+a[p]+su>=x)p-=i;else su+=a[p];
}
return p+1;
}
void gb(int t){for(int i=1;i<=n;++i){if(tg[i]!=TG)a[i]=0;ju[t][i]=ju[t][i-(i&-i)]+a[i];}for(int i=1;i<=n;++i)ju[t][i]+=i;}
}ar;
void add2(int t,int x,int y){
int k=(x-1)/qs;
for(int i=x;i<=(k+1)*qs;++i)ju[t][i]+=y;
for(++k;k*qs+1<=n;++k)ad[t][k]+=y;
}
int main(){
//cout<<(sizeof(ju)>>20)<<endl;
scanf("%d",&n);for(int i=1;i<=n;++i)scanf("%d",b+i),b[i]=i-b[i];scanf("%d",&qn);
for(int l=1,r;r!=n;l=r+1){r=min(l+sq-1,n);lp[++kn]=l,rp[kn]=r;for(int i=l;i<=r;++i)be[i]=kn;}
for(int t=1;t<=kn;++t){
++TG; for(int i=lp[t];i<=rp[t];++i)po[i]=ar.ask(b[i]),ar.add(po[i]);
ar.gb(t);
}
while(qn--){
int o,x,y;scanf("%d%d",&o,&x);if(o==1){
scanf("%d",&y);b[x]=x-y;int k=be[x],ls;
++TG;for(int i=lp[k];i<=rp[k];++i){
if(i<x)ar.add(po[i]);else{
ls=po[i],po[i]=ar.ask(b[i]),ar.add(po[i]);
if(ls==po[i])continue;
if(ls==po[i]-1){--ju[k][ls];continue;}
if(ls==po[i]+1){++ju[k][po[i]];continue;}
assert(i==x);
add2(k,ls,-1),add2(k,po[i],1);
}
}
}else{
int t=be[x],re=b[x];for(int i=x+1;i<=rp[t];++i)re+=b[i]<=re;
for(++t;t<=kn;++t)re=ju[t][re]+ad[t][(re-1)/qs];
printf("%d\n",re);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN=100005,B=500,BC=(MAXN/B)+1;
struct BlockCnt
{
int f[MAXN],g[BC];
void add(int p,int d)
{
f[p]+=d;
g[(p-1)/B]+=d;
}
void query(int k,int &p,int &s)
{
s=k;
for (int i=0;;i++)
{
if ((i+1)*B+g[i]>=s)
for (int j=i*B+1;;j++)
{
if (j+f[j]>=s)
{
p=j;
return;
}
s-=f[j];
}
s-=g[i];
}
}
}cnt[BC];
struct TransInfo
{
int v1[MAXN],v2[BC];
void add(int k,int d)
{
v1[k]+=d;
}
void add(int l,int r,int d)
{
int lc=(l-1)/B,rc=(r-1)/B;
if (lc==rc)
for (int i=l;i<=r;i++)
v1[i]+=d;
else
{
for (int i=l;;i++)
{
v1[i]+=d;
if (i%B==0)
break;
}
for (int i=r;;i--)
{
v1[i]+=d;
if (i%B==1)
break;
}
for (int i=lc+1;i<rc;i++)
v2[i]+=d;
}
}
}tr[BC];
int n,b[MAXN],mn[MAXN],rmd[MAXN],cnt_mod[MAXN];
void build(int k,int l,int r)
{
for (int i=l;i<=r;i++)
{
cnt[k].query(b[i],mn[i],rmd[i]);
tr[k].v1[mn[i]]++;
cnt[k].add(mn[i],1);
}
for (int i=2;i<=n;i++)
tr[k].v1[i]+=tr[k].v1[i-1];
}
int main()
{
#ifdef KeyID
freopen("read.txt","r",stdin);
#endif
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&b[i]);
b[i]=i-b[i];
}
for (int i=1;i<=n;i+=B)
build((i-1)/B,i,min(i+B-1,n));
int m;
scanf("%d",&m);
while (m--)
{
int op;
scanf("%d",&op);
if (op==1)
{
int p,v;
scanf("%d%d",&p,&v);
v=p-v;
if (b[p]==v)
continue;
int k=(p-1)/B,r=min(n,(k+1)*B);
for (int i=r;i>=p;i--)
cnt[k].add(mn[i],-1);
int mnp,rmdp;
cnt[k].query(v,mnp,rmdp);
if (mn[p]==mnp)
for (int i=p;i<=r;i++)
cnt[k].add(mn[i],1);
else if (mn[p]<mnp)
{
tr[k].add(mn[p],mnp-1,-1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]-1]+(mn[p]<mn[i]&&mnp>=mn[i]?1:0);
if (mn[i]+cnt[k].f[mn[i]]<rmd[i]+d)
{
rmd[i]=rmd[i]-cnt[k].f[mn[i]]+d;
cnt_mod[mn[i]]++;
tr[k].add(mn[i]++,-1);
}
else
rmd[i]+=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]-1]=0;
}
else
{
tr[k].add(mnp,mn[p]-1,1);
cnt[k].add(mnp,1);
for (int i=p+1;i<=r;i++)
{
int d=cnt_mod[mn[i]]+(mn[p]>=mn[i]&&mnp<mn[i]?1:0);
if (mn[i]-1+d>=rmd[i])
{
rmd[i]=rmd[i]+cnt[k].f[mn[i]-1]-d;
cnt_mod[mn[i]]++;
tr[k].add(--mn[i],1);
}
else
rmd[i]-=d;
cnt[k].add(mn[i],1);
}
for (int i=p+1;i<=r;i++)
cnt_mod[mn[i]+1]=0;
}
b[p]=v;
mn[p]=mnp;
rmd[p]=rmdp;
}
else
{
int p;
scanf("%d",&p);
int k=b[p];
for (int r=min(((p-1)/B+1)*B,n),i=p+1;i<=r;i++)
if (b[i]<=k)
k++;
for (int i=(p-1)/B+1;i*B<n;i++)
k+=tr[i].v1[k]+tr[i].v2[(k-1)/B];
printf("%d\n",k);
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define FOR(x,n) for(int x=0;x<n;x++)
#define mp make_pair
#define PI 3.14159265358979323846264338327950288
typedef long long ll;
typedef pair<int,int> ii;
#define SEGTYPE int
#define SEGFN max
#define SEGMX INT_MIN // Change to INT_MIN or LLONG_MIN for range max query
const int MX = 1e5 + 1;
const int CHKSIZE = 250;
const int CHKS = MX/CHKSIZE + 1;
class fenwickTree {
public:
int* tree;
int size;
int get(int index) {
index++; // dummy node indexing
int ret = 0;
while(index > 0) {
ret += tree[index];
index -= (index & -index);
}
return ret;
}
void update(int index, int delta) {
if(index >= size) return;
index++; // dummy node indexing
while(index <= size) {
tree[index] += delta;
index += (index & -index);
}
}
int lbound(int x) {
int curr = 0, currsum = 0;
for(int i = 20; i >= 0; i--) {
int bit = (1 << i);
int up = curr + bit;
if(up > size || currsum + tree[up] >= x) continue;
curr = up;
currsum += tree[up];
}
return curr;
}
fenwickTree() {
size = MX;
tree = new int[size+1]; // +1 for dummy node at 0
memset(tree, 0, sizeof(int)*(size+1));
for(int i = 1; i < size; i++) {
update(i, 1);
}
}
};
int n;
int arr[MX], rollback[MX], nxt[2*MX];
fenwickTree trees[CHKS];
void upd1(int i, int val) {
int idx = i/CHKSIZE;
int start = i;
int end = min(idx*CHKSIZE + CHKSIZE, n) - 1;
for(int j = end; j >= i; j--) {
trees[idx].update(rollback[j], -1);
}
arr[i] = val;
for(int j = i; j <= end; j++) {
int x = trees[idx].lbound(arr[j]);
rollback[j] = x;
trees[idx].update(x, 1);
}
}
int query2(int i) {
int curr = arr[i];
i++;
while(i < n && nxt[i] == -1) {
if(arr[i] <= curr) curr++;
i++;
}
while(i < n) {
curr = trees[i/CHKSIZE].get(curr);
i = nxt[i];
}
return n - curr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
memset(nxt, -1, sizeof nxt);
for(int i = 0; i < 2*MX; i += CHKSIZE) {
nxt[i] = i + CHKSIZE;
}
scanf("%d", &n);
FOR(i,n) {
scanf("%d", &arr[i]);
}
FOR(i,MX) rollback[i] = n;
int chks = (n + CHKSIZE - 1)/CHKSIZE;
FOR(i,chks) {
upd1(CHKSIZE * i, arr[CHKSIZE * i]);
}
int q;
scanf("%d", &q);
while(q--) {
int t;
scanf("%d", &t);
if(t == 1) {
int i, x;
scanf("%d %d", &i, &x);
i--;
upd1(i, x);
}
else {
int i;
scanf("%d", &i);
i--;
printf("%d\n", query2(i));
}
}
}
// UPDATE N WHEN UR DONE AAAAAAAAAAAAAAAAAAAAAAAAAAA (if it applies lol)
|
// problem:
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mk make_pair
#define lob lower_bound
#define upb upper_bound
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
template<typename T> inline void ckmax(T & x, T y) {
x = (y > x ? y : x);
}
template<typename T> inline void ckmin(T & x, T y) {
x = (y < x ? y : x);
}
const int n = 100352;
const int lgbt = 9;
const int b = 1 << lgbt;
int indexes[lgbt + 1][n];
int values[lgbt + 1][n];
int arr[n];
void merge(int k, int l) {
int end = k + (1 << l);
int mid = k + (1 << (l - 1));
int x = mid;
int y = k;
for (int z = k; z < end; z++) {
if (y < mid && (x == end || values[l - 1][y] + (x - mid) < values[l - 1][x])) {
indexes[l][z] = indexes[l - 1][y];
values[l][z] = values[l - 1][y] + (x - mid);
y++;
} else {
indexes[l][z] = indexes[l - 1][x];
values[l][z] = values[l - 1][x];
x++;
}
}
}
void assign(int k) {
for (int x = k; x < k + b; x++) {
arr[indexes[lgbt][x]] = values[lgbt][x];
}
}
int find(int k, int x) {
int upper = b;
int lower = 0;
while (upper > lower) {
int mid = (upper + lower) / 2;
if (x + mid < values[lgbt][k + mid]) {
upper = mid;
} else {
lower = mid + 1;
}
}
return x + upper;
}
void update(int k) {
for (int l = 1; l <= lgbt; l++) {
k = (k >> l) << l;
merge(k, l);
}
assign(k);
}
int calc(int k) {
int x = arr[k];
k = ((k >> lgbt) << lgbt) + b;
for (; k < n; k += b) {
x = find(k, x);
}
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int nActual;
cin >> nActual;
for (int x = 0; x < n; x++) {
indexes[0][x] = x;
if (x < nActual) {
int a;
cin >> a;
values[0][x] = x - a;
} else {
values[0][x] = x;
}
}
for (int l = 1; l <= lgbt; l++) {
for (int k = 0; k < n; k += 1 << l) {
merge(k, l);
}
}
for (int k = 0; k < n; k += b) {
assign(k);
}
int q;
for (cin >> q; q; q--) {
int type, k;
cin >> type >> k;
k--;
if (type == 1) {
int a;
cin >> a;
values[0][k] = k - a;
update(k);
} else {
cout << calc(k) + 1 << ' ';
}
}
cout << '\n';
return 0;
} |
/**
* author: tourist
* created: 25.06.2021 19:43:15
**/
#undef _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
#define sz(s) ((int) s.size())
// https://github.com/kth-competitive-programming/kactl/blob/main/content/data-structures/FenwickTree.h
struct FT {
vector<int> s;
FT(int n) : s(n) {}
void update(int pos, int dif) { // a[pos] += dif
for (; pos < sz(s); pos |= pos + 1) s[pos] += dif;
}
int query(int pos) { // sum of values in [0, pos)
int res = 0;
for (; pos > 0; pos &= pos - 1) res += s[pos-1];
return res;
}
int lower_bound(int sum) {// min pos st sum of [0, pos] >= sum
// Returns n if no sum is >= sum, or -1 if empty sum is.
if (sum <= 0) return -1;
int pos = 0;
for (int pw = 1 << 19; pw; pw >>= 1) {
if (pos + pw <= sz(s) && s[pos + pw-1] < sum)
pos += pw, sum -= s[pos-1];
}
return pos;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> b(n);
for (int i = 0; i < n; i++) {
cin >> b[i];
}
const int BLOCK = max(1, (int) sqrt(0.2 * n));
const int cnt = (n + BLOCK - 1) / BLOCK;
vector<int> L(cnt);
vector<int> R(cnt);
vector<vector<int>> app(cnt);
FT fenw(n + 1);
for (int i = 1; i <= n; i++) {
fenw.update(i, +1);
}
auto Build = [&](int bid) {
for (int j = L[bid]; j < R[bid]; j++) {
int& val = app[bid][j - L[bid]];
val = max(0, fenw.lower_bound(b[j]));
// debug(bid, j, val);
fenw.update(val, +1);
}
for (int j = L[bid]; j < R[bid]; j++) {
int& val = app[bid][j - L[bid]];
fenw.update(val, -1);
}
sort(app[bid].begin(), app[bid].end());
// debug(bid, b, app[bid]);
};
for (int i = 0; i < cnt; i++) {
L[i] = i * BLOCK;
R[i] = min(n, (i + 1) * BLOCK);
app[i].resize(R[i] - L[i]);
Build(i);
}
int tt;
cin >> tt;
while (tt--) {
int op;
cin >> op;
if (op == 1) {
int i, x;
cin >> i >> x;
--i;
b[i] = x;
Build(i / BLOCK);
} else {
int i;
cin >> i;
--i;
int bid = i / BLOCK;
int res = b[i];
for (int j = i + 1; j < R[bid]; j++) {
res += (res >= b[j]);
}
for (int k = bid + 1; k < cnt; k++) {
res += (int) (upper_bound(app[k].begin(), app[k].end(), res) - app[k].begin());
}
cout << n - res << '\n';
}
}
debug(clock());
return 0;
}
|
#include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) cout<<i<<" ";puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
const int N = 1e5+10, M = 1010;
int n,q,B,a[N],id[N],cnt[M];
int b[M],tag[M<<2];
pa mn[M<<2];
inline void Build(int u,int l,int r){
tag[u]=0;
if (l==r) return mn[u]=mp(b[l],l),void(0);
int mid=l+r>>1;
Build(u<<1,l,mid),Build(u<<1^1,mid+1,r);
mn[u]=min(mn[u<<1],mn[u<<1^1]);
}
inline void update(int u,int l,int r,int ql){
if (l>ql) return tag[u]--,mn[u].fi--,void(0);
if (l==r) return mn[u]=mp(1e9,l),void(0);
int mid=l+r>>1;
update(u<<1^1,mid+1,r,ql);
if (ql<=mid) update(u<<1,l,mid,ql);
mn[u]=min(mn[u<<1],mn[u<<1^1]),mn[u].fi+=tag[u];
}
int v[M][M];
inline void ReBuild(int id){
int l=(id-1)*B+1,r=min(id*B,n),cnt=0;
For(i,l,r) b[++cnt]=a[i];
Build(1,1,cnt);
For(i,1,cnt){
int tmp=mn[1].fi;
v[id][i]=max(tmp,v[id][i-1]),update(1,1,cnt,mn[1].se);
}
}
inline int Query(int x){
int y=a[x];
For(i,x+1,min(id[x]*B,n)) y+=(y>=a[i]);
For(i,id[x]+1,id[n]){
int tmp=upper_bound(v[i]+1,v[i]+cnt[i]+1,y)-v[i]-1;
y+=tmp;
}
return n-y;
}
int main(){
n=read(),B=250;
For(i,1,n) a[i]=read(),id[i]=(i-1)/B+1,cnt[id[i]]++;
For(i,1,id[n]) ReBuild(i);
q=read();
while (q--){
int op=read(),x=read();
if (op==1){
int y=read();
a[x]=y,ReBuild(id[x]);
} else {
printf("%d\n",Query(x));
}
}
} |
#include<bits/stdc++.h>
using namespace std;
const int N=200005;
const int B=200;
int n,cnt,b[N],Q;
int L[N],R[N],q[5*B+2][B+5],top[N];
int t[N];
void build(int k){
top[k]=0;
for (int i=R[k];i>=L[k];i--){
int p=0,rem=b[i];
for (int j=1<<16;j;j>>=1)
if ((p+j)<=n&&j-t[j+p]<rem)
p+=j,rem-=j-t[p];
q[k][++top[k]]=++p;
for (;p<=n;p+=p&(-p)) t[p]++;
}
for (int i=1;i<=top[k];i++)
for (int p=q[k][i];p<=n;p+=p&(-p))
t[p]=0;
sort(q[k]+1,q[k]+top[k]+1);
for (int i=1;i<=top[k];i++) q[k][i]-=i-1;
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++){
scanf("%d",&b[i]);
b[i]=i-b[i];
}
cnt=(n-1)/B+1;
for (int i=1;i<=cnt;i++){
L[i]=(i-1)*B+1;
R[i]=min(n,i*B);
build(i);
}
scanf("%d",&Q);
while (Q--){
int tp,x;
scanf("%d%d",&tp,&x);
if (tp==1){
scanf("%d",&b[x]);
b[x]=x-b[x];
build((x-1)/B+1);
}
else{
int be=(x-1)/B+1;
int ans=b[x];
for (int i=x+1;i<=R[be];i++)
if (b[i]<=ans) ++ans;
for (int i=be+1;i<=cnt;i++)
ans+=upper_bound(q[i]+1,q[i]+top[i]+1,ans)-q[i]-1;
printf("%d\n",ans);
}
}
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, a, d;
int t[100005], v[100005];
double ans[100005];
int main() {
cin.tie(0);
cin >> n >> a >> d;
for (int i = 1; i <= n; i++) cin >> t[i] >> v[i];
ans[0] = 0;
for (int i = 1; i <= n; i++) {
double tt = 1.0 * v[i] / a;
double dd = 0.5 * a * tt * tt, res = -1;
if (dd < d) {
res = tt + (d - dd) / v[i];
} else {
res = sqrt(2.0 * d / a);
}
ans[i] = res + t[i];
ans[i] = max(ans[i], ans[i - 1]);
cout << fixed << setprecision(10) << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n;
double a, d;
double p[maxn], t[maxn], v[maxn], s[maxn];
int main() {
scanf("%d %lf %lf", &n, &a, &d);
for (int i = 0; i < n; i++)
scanf("%lf%lf", &t[i], &v[i]), p[i] = t[i] + v[i] / a;
s[0] = t[0] + v[0] / a + (d - 0.5 * a * v[0] / a * v[0] / a) / v[0];
if (0.5 * a * v[0] / a * v[0] / a > d)
s[0] = min(s[0], t[0] + sqrt((d * 2) / a));
for (int i = 1; i < n; i++) {
s[i] = t[i] + v[i] / a + (d - 0.5 * a * v[i] / a * v[i] / a) / v[i];
if (0.5 * a * v[i] / a * v[i] / a > d)
s[i] = min(s[i], t[i] + sqrt((d * 2) / a));
s[i] = max(s[i], s[i - 1]);
}
for (int i = 0; i < n; i++) printf("%.6f\n", s[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
double tstart[100100], vmax[100100], tf[100100];
double ds[100100], ts[100100], vs[100100];
double a, d, td, vd, dd;
int N, i, niv;
int main() {
scanf("%d %lf %lf", &N, &a, &d);
niv = 0;
for (i = 1; i <= N; i++) {
scanf("%lf %lf", &tstart[i], &vmax[i]);
td = sqrt(2 * d / a);
vd = a * td;
if (vd > vmax[i]) {
vd = vmax[i];
td = vd / a;
}
dd = a * td * td / 2.0;
td += tstart[i];
while (niv > 0) {
double li, ls, mid, tmeet = -1.0;
li = max(tstart[i], ts[niv]);
ls = tf[niv];
if (niv > 1) ls = ts[niv - 1];
while (li <= ls && fabs(ls - li) > 1e-8) {
mid = 0.5 * (li + ls);
double posi, posprev;
if (mid <= td)
posi = a * (mid - tstart[i]) * (mid - tstart[i]) / 2.0;
else
posi = dd + (mid - td) * vd;
posprev = ds[niv] + (mid - ts[niv]) * vs[niv];
if (posprev <= posi || fabs(posprev - posi) <= 1e-8) {
tmeet = mid;
ls = mid;
} else
li = mid;
}
if (tmeet < 0.5)
niv--;
else {
ds[niv] += (tmeet - ts[niv]) * vs[niv];
ts[niv] = tmeet;
niv++;
if (tmeet <= td) {
ts[niv] = tmeet;
vs[niv] = a * (tmeet - tstart[i]);
ds[niv] = a * (tmeet - tstart[i]) * (tmeet - tstart[i]) / 2.0;
tf[niv] = tf[niv - 1];
} else {
ts[niv] = td;
vs[niv] = vd;
tf[niv] = tf[niv - 1];
ds[niv] = dd;
}
break;
}
}
if (niv == 0) {
niv = 1;
ts[niv] = td;
vs[niv] = vd;
ds[niv] = dd;
tf[niv] = ts[niv] + (d - ds[niv]) / vs[niv];
}
printf("%.6lf\n", tf[niv]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int n, k, d;
cin >> n >> k >> d;
vector<pair<int, int> > A(n);
for (int i = 0; i < n; i++) {
cin >> A[i].first >> A[i].second;
A[i].second = -A[i].second;
}
sort(A.begin(), A.end());
double prev = -1;
for (int i = 0; i < n; i++) {
double t = 1. * -A[i].second / k;
double s = t * t * k / 2;
if (s < d) {
double p = (1. * d - s) / -A[i].second;
t += p;
} else {
t = sqrt(1. * d / k * 2);
}
t += A[i].first;
if (prev < t) {
prev = t;
cout << fixed << setprecision(6) << t << endl;
} else
cout << fixed << setprecision(6) << prev << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char *sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
vector<string> split(string s) {
istringstream buf(s);
istream_iterator<string> beg(buf), end;
vector<string> list(beg, end);
return list;
}
bool isvowel(char c) {
string s = "aeiouAEIOU";
if (find(s.begin(), s.end(), c) != s.end()) return true;
return false;
}
vector<long long> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) {
prime[j] = 0;
}
}
vector<long long> p;
for (int i = 2; i <= prime.size(); i++)
if (prime[i]) p.push_back(i);
return p;
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true && (n != 1);
}
int ncr(long long n, long long r) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[r];
}
bool special(string s) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') continue;
if (s[i] == '#')
return true;
else
return false;
}
return false;
}
void solve() {
cout << fixed << setprecision(10);
double n, a, d;
cin >> n >> a >> d;
vector<pair<int, int> > v(n);
double max_ans = 0;
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
double s1 = 1.0 * v[i].second * v[i].second / (2 * a);
double t = v[i].first;
if (d < s1)
t += sqrt(2 * d / a);
else
t += 1.0 * v[i].second / a + (d - s1) / v[i].second;
max_ans = max(t, max_ans);
cout << max_ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, d, t[100100], v[100100];
double ans[100100];
int main() {
scanf("%d %d %d", &n, &a, &d);
for (int i = 0; i < n; i++) scanf("%d %d", &t[i], &v[i]);
for (int i = 0; i < n; i++) {
double tt = v[i] * 1.0 / a;
double dt = a * tt * tt / 2;
if (d > dt)
ans[i] = tt + (d - dt) / v[i];
else
ans[i] = sqrt(2.0 * d / a);
ans[i] += t[i];
if (i) ans[i] = max(ans[i], ans[i - 1]);
printf("%.6lf\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct truck {
double t;
double v;
double f;
} T[100001];
int main() {
int n;
double a, d;
cin >> n >> a >> d;
double mb;
for (int i = 0; i < n; i++) {
cin >> T[i].t >> T[i].v;
double t = T[i].v / a;
double s = .5 * a * t * t;
double total_time;
if (s > d) {
total_time = sqrt((d * 2) / a) + T[i].t;
} else {
double S = (d - s);
total_time = (S / T[i].v) + t + T[i].t;
}
T[i].f = total_time;
for (int j = i - 1; j >= 0; j--) {
if (T[i].f - T[j].f <= 0.00000004) {
T[i].f = T[j].f;
break;
} else
break;
}
printf("%.5lf\n", T[i].f);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > g;
vector<pair<double, int> > res;
vector<double> answer;
int i, n, t_i, v_i, j;
double a, d;
int main() {
cin >> n >> a >> d;
for (i = 0; i < n; i++) {
cin >> t_i >> v_i;
g.push_back(make_pair(make_pair(t_i, v_i), i));
}
sort(g.begin(), g.end());
res.resize(n);
answer.resize(n);
for (i = 0; i < n; i++) {
double v_needed = 0;
(sqrt(2 * a * d) > g[i].first.second) ? v_needed = g[i].first.second
: v_needed = sqrt(2 * a * d);
double pr_t = v_needed / a;
double pr = (pr_t * pr_t * a) / 2;
double r = (d - pr) / g[i].first.second + pr_t;
if (i == 0) {
res[i] = make_pair(r, g[i].second);
} else {
if (g[i].first.first - g[i - 1].first.first < res[i - 1].first - r) {
res[i] = make_pair(
res[i - 1].first + g[i - 1].first.first - g[i].first.first,
g[i].second);
} else
res[i] = make_pair(r, g[i].second);
}
}
for (j = 0; j < n; j++) {
long double ans = res[j].first + g[j].first.first;
answer[res[j].second] = ans;
}
for (i = 0; i < answer.size(); i++) {
cout << setprecision(20) << answer[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, a, d;
int t[100005], v[100005];
double ans[100005];
int main() {
cin.tie(0);
cout.tie(0);
cin >> n >> a >> d;
for (int i = 1; i <= n; i++) cin >> t[i] >> v[i];
ans[0] = 0;
for (int i = 1; i <= n; i++) {
double tt = 1.0 * v[i] / a;
double dd = 0.5 * a * tt * tt, res = -1;
if (dd < d) {
res = tt + (d - dd) / v[i];
} else {
res = sqrt(2.0 * d / a);
}
ans[i] = res + t[i];
ans[i] = max(ans[i], ans[i - 1]);
cout << fixed << setprecision(10) << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, d;
long long t, v;
double prev = 0;
scanf("%I64d%I64d%I64d", &n, &a, &d);
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d", &t, &v);
double tt = sqrt((2 * d) / (a * 1.0));
if (tt * a > v) {
tt = v / (a * 1.0) + (d - v * v / (2 * a * 1.0)) / v;
}
tt += t;
if (tt < prev) tt = prev;
printf("%.8lf\n", tt);
prev = tt;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, d;
int t[1000000], v[1000000];
double ret[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> a >> d;
for (int i = 0; i < (int)(n); i++) cin >> t[i] >> v[i];
for (int i = 0; i < (int)(n); i++) {
double tms = (double)v[i] / a;
double x = 0.5 * a * tms * tms;
if (d > x) {
ret[i] = t[i] + tms + (d - x) / v[i];
} else {
ret[i] = t[i] + sqrt(2.0 * d / a);
}
}
for (int i = (int)(1); i < (int)(n); i++) ret[i] = max(ret[i], ret[i - 1]);
cout << fixed << setprecision(5);
for (int i = 0; i < (int)(n); i++) cout << ret[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t1;
double aa, d;
int check(double x, double v) {
if (x <= v / aa) {
double ha = aa * x;
return ha * x >= d * 2.0;
} else {
double t = v / aa, la = x - t;
return t * v >= (d - la * v) * 2;
}
}
int main() {
double mn, mx = -1, t, v, l, r, mid, now, eps = 1e-11;
scanf("%d%lf%lf", &t1, &aa, &d);
mx = -1;
while (t1--) {
scanf("%lf%lf", &t, &v);
l = 0;
r = 1e8;
mn = r;
while (r - l > eps) {
mid = (l + r) / 2.0;
if (check(mid, v)) {
mn = min(mn, mid);
r = mid;
} else
l = mid;
}
now = mn + t;
if (now > mx + eps) {
printf("%.13lf\n", now);
mx = now;
} else
printf("%.13lf\n", mx);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, d;
double t[100005];
cin >> n >> a >> d;
memset(t, 0, sizeof(t));
for (int i = 1; i <= n; i++) {
int tt, v;
double s;
cin >> tt >> v;
double ttt = (double)v / a;
s = 0.5 * a * ttt * ttt;
if (s <= d) {
t[i] = tt + ttt + (double)(d - s) / (double)v;
} else {
t[i] = tt + sqrt(((2.0 * (double)d)) / (double)a);
}
if (t[i] <= t[i - 1]) {
printf("%.10f\n", t[i - 1]);
t[i] = t[i - 1];
} else
printf("%.10f\n", t[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, d;
int n;
double timesmax = 0, timethis;
cin >> n >> a >> d;
for (int i = 0; i < n; i++) {
double t, v, d1, t1;
cin >> t >> v;
d1 = v * v / 2.0 / a;
if (d1 > d)
timethis = t + sqrt(2.0 * d / a);
else
timethis = t + (d - d1) / v + v / a;
if (timethis < timesmax)
timethis = timesmax;
else
timesmax = timethis;
printf("%.8f\n", timethis);
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, a, d;
scanf("%d", &n);
scanf("%d", &a);
scanf("%d", &d);
int atv[n][3];
for (int i = 0; i < n; i++) {
scanf("%d", &atv[i][0]);
scanf("%d", &atv[i][1]);
atv[i][2] = i;
}
long double ts[n][3];
long double delta = 0;
for (int i = 0; i < n; i++) {
ts[i][0] = (long double)atv[i][1] / a;
if (((a * ts[i][0] * ts[i][0]) / 2) < (long double)d)
ts[i][1] = ts[i][0] +
(d - (long double)(a * ts[i][0] * ts[i][0]) / 2) / atv[i][1] +
atv[i][0];
else
ts[i][1] = sqrt((long double)2 * d / a) + atv[i][0];
if (ts[i][1] < ts[i - 1][1] && i > 0) ts[i][1] = ts[i - 1][1];
}
for (int i = 0; i < n; i++) {
printf("%f ", (float)ts[i][1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char *sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
vector<string> split(string s) {
istringstream buf(s);
istream_iterator<string> beg(buf), end;
vector<string> list(beg, end);
return list;
}
bool isvowel(char c) {
string s = "aeiouAEIOU";
if (find(s.begin(), s.end(), c) != s.end()) return true;
return false;
}
vector<long long> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) {
prime[j] = 0;
}
}
vector<long long> p;
for (int i = 2; i <= prime.size(); i++)
if (prime[i]) p.push_back(i);
return p;
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true && (n != 1);
}
int ncr(long long n, long long r) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[r];
}
bool special(string s) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') continue;
if (s[i] == '#')
return true;
else
return false;
}
return false;
}
void solve() {
cout << fixed << setprecision(10);
int n;
double a, d;
cin >> n >> a >> d;
double max_ans = 0;
for (int i = 0; i < n; i++) {
int t1, v;
cin >> t1 >> v;
double s1 = 1.0 * v * v / (2 * a);
double t = t1;
if (d < s1)
t += sqrt(2 * d / a);
else
t += 1.0 * v / a + (d - s1) / v;
max_ans = max(t, max_ans);
cout << max_ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, a, d;
double ans, lastAns;
scanf("%lf %lf %lf", &n, &a, &d);
for (int i = 0; i < n; i++) {
double t;
double v;
scanf("%lf %lf", &t, &v);
double x = v / a;
double dist = x * x * a / 2;
if (dist < d) {
double p = d - dist;
ans = p / v + x;
} else
ans = sqrt(2 * d / a);
ans += t;
if (i > 0) ans = max(lastAns, ans);
lastAns = ans;
printf("%0.4lf \n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double t1, t2, s, v1, v2, a, vmax, t0, s1, s2, before;
int i, j, m, n, k;
while (cin >> k >> a >> s) {
before = 0;
while (k--) {
cin >> t0 >> vmax;
t1 = vmax / a;
if (a * t1 * t1 / 2 < s) {
s1 = a * t1 * t1 / 2;
s2 = s - s1;
t2 = s2 / vmax;
if (t0 + t1 + t2 < before)
printf("%.10lf\n", before);
else
printf("%.10lf\n", t0 + t1 + t2);
before = max(t0 + t1 + t2, before);
} else {
if (sqrt(2 * s / a) + t0 < before)
printf("%.10lf\n", before);
else
printf("%.10lf\n", sqrt(2 * s / a) + t0);
before = max(before, sqrt(2 * s / a) + t0);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
long double a, d;
cin >> n >> a >> d;
long long int v[n], t[n];
long double ans[n];
for (int i = 0; i <= n - 1; i++) {
cin >> t[i] >> v[i];
}
long double di = (long double)((v[0] * v[0]) / (2.0 * a));
if (di > d) {
ans[0] = t[0] + (long double)sqrt((2.0 * d) / a);
} else {
long double rem = d - di;
long double ti = (long double)(v[0] / a);
ans[0] = t[0] + ti + (long double)(rem / v[0]);
}
for (int i = 1; i <= n - 1; i++) {
di = (long double)((v[i] * v[i]) / (2.0 * a));
if (di > d) {
long double temp = (long double)sqrt((2.0 * d) / a);
if (temp + t[i] < ans[i - 1]) {
ans[i] = ans[i - 1];
} else {
ans[i] = t[i] + temp;
}
} else {
long double rem = d - di;
long double ti = (long double)(v[i] / a);
long double temp = ti + (long double)(rem / v[i]);
if (temp + t[i] < ans[i - 1]) {
ans[i] = ans[i - 1];
} else {
ans[i] = t[i] + temp;
}
}
}
for (int i = 0; i <= n - 1; i++)
cout << fixed << setprecision(6) << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, a, d;
cin >> n >> a >> d;
double Max = 0, time, t, v;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &t, &v);
if (d > v * v / (2 * a))
time = v / a + (d - v * v / (2 * a)) / v;
else
time = sqrt(2 * d / a);
time += t;
Max = max(Max, time);
printf("%0.5lf\n", Max);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double prediction(int v, int d, int a) {
double t = (double)v / a;
double dd = a * t * t / 2;
if (dd >= d) return sqrt((double)2 * d / a);
return t + (d - dd) / v;
}
int main() {
int n, a, d;
cin >> n >> a >> d;
double last_ans = 0;
for (int i = 0; i < n; ++i) {
int t, v;
cin >> t >> v;
double ans = t + prediction(v, d, a);
if (ans < last_ans) {
ans = last_ans;
}
printf("%.10lf\n", ans);
last_ans = ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef int (*array)[2];
typedef double *B[2];
int main() {
int n, x;
double y;
int tmp;
int index = 0;
cin >> n >> x >> y;
double **p = new double *[n];
for (int i = 0; i < n; ++i) p[i] = new double[2];
while (index < n) {
cin >> p[index][0] >> p[index][1];
index++;
}
double time, distance;
time = p[0][1] / x;
distance = x * time * time / 2;
if (distance >= y) {
time = sqrt(2 * y / x) + p[0][0];
cout << fixed << setprecision(10) << time << endl;
} else {
time += (y - distance) / (p[0][1]) + p[0][0];
cout << fixed << setprecision(10) << time << endl;
}
for (int i = 1; i < n; ++i) {
double t1 = double(p[i][1]) / x;
double dis = x * t1 * t1 / 2;
if (dis >= y) {
t1 = sqrt(2 * y / x) + p[i][0];
if (t1 <= time)
cout << fixed << setprecision(10) << time << endl;
else {
time = t1;
cout << fixed << setprecision(10) << time << endl;
}
} else {
t1 += (y - dis) / p[i][1] + p[i][0];
if (t1 <= time)
cout << fixed << setprecision(10) << time << endl;
else {
time = t1;
cout << fixed << setprecision(10) << time << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const double EPS = 1e-10;
int main() {
int n, a, d;
while (cin >> n >> a >> d) {
double prev = 0.0;
for (int i = 0; i < n; ++i) {
double t, v;
cin >> t >> v;
double td = v / a;
double dd = 0.5 * a * td * td;
double ans = 0.0;
if (d - dd < EPS) {
ans = t + sqrt((2.0 * d) / a);
} else {
ans = t + td + (d - dd) / v;
}
if (ans - prev < EPS) {
printf("%.10f\n", prev);
} else {
prev = ans;
printf("%.10f\n", ans);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double t[100010], v[100010];
int n;
double a, d;
double ans[100010];
int main() {
scanf("%d%lf%lf", &n, &a, &d);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &t[i], &v[i]);
}
for (int i = 0; i < n; i++) {
if (2 * a * d > v[i] * v[i])
ans[i] = t[i] + v[i] / a + (d - v[i] * v[i] / a / 2) / v[i];
else {
ans[i] = sqrt(2 * a * d) / a + t[i];
}
ans[i] = max(ans[i], ans[i - 1]);
printf("%.5lf\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
const int MX = 1e5 + 5;
int n, a, d;
vector<pair<int, int> > arr;
double solve(int maxSpeed) {
double timeForMaxSpeed = maxSpeed * 1.0 / a;
double timeForEndAcceleratingSq = sqrt(2 * d * 1.0 / a);
if (timeForMaxSpeed - timeForEndAcceleratingSq > EPS)
return timeForEndAcceleratingSq;
double distMovedWhileAcc = (timeForMaxSpeed * timeForMaxSpeed * a * 0.5);
double leftDist = d - distMovedWhileAcc;
double leftTime = leftDist * 1.0 / (1.0 * maxSpeed);
return leftTime + timeForMaxSpeed;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> d;
arr.resize(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr.begin(), arr.end());
double last = 0;
cout << fixed << setprecision(6);
for (int i = 0; i < n; i++) {
double myMinTime = solve(arr[i].second) + arr[i].first;
cout << max(myMinTime, last) << endl;
last = max(myMinTime, last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 10;
struct node {
int t, v;
} ed[N];
double ans[N];
int main() {
double n, a, d;
scanf("%lf%lf%lf", &n, &a, &d);
for (int i = 1; i <= n; i++) {
double t, v;
scanf("%lf%lf", &t, &v);
if (v * v >= 2 * a * d)
ans[i] = sqrt(2 * d / a) + t;
else {
double tmp = v * v / 2 / a;
double x = tmp;
tmp = d - tmp;
ans[i] = tmp / v + sqrt(2 * x / a) + t;
}
}
for (int i = 2; i <= n; i++) {
ans[i] = max(ans[i], ans[i - 1]);
}
for (int i = 1; i <= n; i++) printf("%.7f\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double t[100000];
double v[100000];
double z[100000];
int main() {
int n;
double a, d;
double m;
cin >> n >> a >> d;
for (int i = 0; i < n; ++i) cin >> t[i] >> v[i];
for (int i = 0; i < n; ++i) {
if (d < v[i] * v[i] / (2 * a)) {
z[i] = t[i] + sqrt(2 * d / a);
} else {
z[i] = t[i] + v[i] / a + (d - v[i] * v[i] / (2 * a)) / v[i];
}
}
m = z[0];
for (int i = 1; i < n; ++i) {
if (z[i] <= m)
z[i] = m;
else
m = z[i];
}
cout.setf(cout.fixed);
cout.precision(10);
for (int i = 0; i < n; ++i) cout << z[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[110000];
double v[110000], p[110000];
class nod {
public:
int id;
double t, v, ar;
} s[110000];
int main() {
int n;
double a, d;
scanf("%d%lf%lf", &n, &a, &d);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &s[i].t, &s[i].v);
if (s[i].v * s[i].v < d * 2 * a) {
s[i].ar = s[i].t + s[i].v / a + d / s[i].v - s[i].v / 2 / a;
} else {
s[i].ar = s[i].t + sqrt(d * 2 / a);
}
}
double tmp = 0;
for (int i = 0; i < n; i++) {
tmp = max(tmp, s[i].ar);
printf("%lf\n", tmp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double a, d, v, ti, pt, t, eps = 0.00000000001, l, r;
int main() {
scanf("%d%lf%lf", &n, &a, &d);
ti = 0.0;
for (int i = 0; i < n; ++i) {
scanf("%lf%lf", &t, &v);
l = 0.0;
r = 3000000000.0;
while (r - l > eps) {
double mi = (r + l) / 2.0;
if (a * mi * mi / 2.0 > d)
r = mi;
else
l = mi;
}
double as = v / a;
if (as <= l)
pt = (d - a * as * as / 2.0) / v + as + t;
else
pt = l + t;
ti = max(ti, pt);
printf("%.10lf\n", ti);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, a, d, t, v, ta, sa, tv, sv;
scanf("%lf%lf%lf", &n, &a, &d);
vector<double> time(n + 1);
for (int i = 1; i <= n; ++i) {
scanf("%lf%lf", &t, &v);
ta = v / a;
sa = a * ta * ta / 2;
if (sa >= d)
time[i] = max(time[i - 1], (t + sqrt(2 * d / a)));
else {
sv = d - sa;
tv = sv / v;
time[i] = max(time[i - 1], (t + ta + tv));
}
printf("%.10lf\n", time[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char *sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
vector<string> split(string s) {
istringstream buf(s);
istream_iterator<string> beg(buf), end;
vector<string> list(beg, end);
return list;
}
bool isvowel(char c) {
string s = "aeiouAEIOU";
if (find(s.begin(), s.end(), c) != s.end()) return true;
return false;
}
vector<long long> sieve(long long n) {
vector<bool> prime(n + 1, true);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) {
prime[j] = 0;
}
}
vector<long long> p;
for (int i = 2; i <= prime.size(); i++)
if (prime[i]) p.push_back(i);
return p;
}
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true && (n != 1);
}
int ncr(long long n, long long r) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]) % 1000000007;
}
return C[r];
}
bool special(string s) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') continue;
if (s[i] == '#')
return true;
else
return false;
}
return false;
}
void solve() {
cout << fixed << setprecision(10);
double n, a, d;
cin >> n >> a >> d;
vector<pair<double, double> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
double max_ans = 0;
for (int i = 0; i < n; i++) {
double s1 = v[i].second * v[i].second / (2 * a);
double t = v[i].first;
if (d < s1) {
t += sqrt(2 * d / a);
} else {
t += v[i].second / a + (d - s1) / v[i].second;
}
t = max(t, max_ans);
cout << t << '\n';
max_ans = t;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double f1(double l, double a, double v) {
double nv = sqrt(l * 2 * a);
return nv / a;
}
double f(double l, double a, double v) {
l = l - 1.0 / 2 * v * v / a;
return v / a + l / v;
}
char s[10485760];
double t[1048576], et[1048576], v[1048576];
int main() {
int n;
double a, b;
while (cin >> n >> a >> b) {
for (int i = 0; i < (n); i++) {
cin >> t[i] >> v[i];
}
for (int i = 0; i < (n); i++) {
if (b < 1.0 / 2 * v[i] * v[i] / a)
et[i] = t[i] + f1(b, a, v[i]);
else
et[i] = t[i] + f(b, a, v[i]);
}
printf("%.10lf\n", et[0]);
for (int i = 0; i < (n - 1); i++) {
if (et[i + 1] <= et[i]) {
et[i + 1] = et[i];
}
printf("%.10lf\n", et[i + 1]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)1e9;
using namespace std;
long long n, a, d, t, v;
double lastT, t1, d1;
int main() {
ios::sync_with_stdio(0);
cin >> n >> a >> d;
for (long long i = 0; i < n; ++i) {
cin >> t >> v;
d1 = v * v * 1.0 / (2.0 * a);
t1 = v * 1.0 / a;
if (d1 <= d) {
d1 = d - d1;
t1 += d1 / v;
t1 += t;
if (t1 >= lastT) lastT = t1;
} else {
t1 = sqrt(2.0 * d / a);
t1 += t;
if (t1 >= lastT) lastT = t1;
}
cout << fixed << setprecision(10) << lastT << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int DEBUG = 0;
double Min(double a, double b) { return (a < b ? a : b); }
double Max(double a, double b) { return (a > b ? a : b); }
double Abs(double a) { return (a >= 0 ? a : -a); }
void print1d(int *vec, int M, const char *str = NULL) {
if (str != NULL) printf("%s ", str);
for (int i = 0; i < M; i++) {
if (i > 0) printf(" ");
printf("%d", vec[i]);
}
printf("\n");
}
struct NODE {
double t, v;
};
int compare_NODE_inc(const void *a_, const void *b_) {
NODE *a = (NODE *)a_;
NODE *b = (NODE *)b_;
if (a->t > b->t)
return 1;
else if (a->t < b->t)
return -1;
else
return 0;
}
int main(int argc, char **argv) {
DEBUG = (argc >= 2) ? atoi(argv[1]) : 0;
int n;
double a, d;
cin >> n >> a >> d;
NODE bus[n];
for (int i = 0; i < n; i++) {
cin >> bus[i].t >> bus[i].v;
}
qsort(bus, n, sizeof(NODE), compare_NODE_inc);
double prevt = 0;
double tim;
for (int i = 0; i < n; i++) {
double t = bus[i].t;
double v = bus[i].v;
if (v * v >= 2.0 * a * d) {
tim = t + sqrt(2.0 * d / a);
} else {
tim = t + (1.0 * d / v + 1.0 * v / 2.0 / a);
}
prevt = Max(tim, prevt);
printf("%.10f\n", prevt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double a, d;
scanf("%d%lf%lf", &n, &a, &d);
double t, v, time = 0.0, s, s1, flag = 0.0, x, y, z;
x = sqrt((2 * d) / a);
y = sqrt(2 * a * d);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &t, &v);
x += t;
if (y >= v) {
time = v / a;
s = 0.5 * a * time * time;
time += t;
s1 = d - s;
time += s1 / v;
flag = max(flag, time);
printf("%0.6f\n", flag);
} else {
flag = max(flag, x);
printf("%.6f\n", flag);
}
x -= t;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i;
double a, d;
double t;
double v;
double ans1, ans2;
int main() {
ans2 = 0.0;
scanf("%d%lf%lf", &n, &a, &d);
for (i = 0; i < n; i++) {
scanf("%lf%lf", &t, &v);
if ((v * v / 2.0 / a) >= d) {
ans1 = sqrt(2.0 * d / a);
} else {
ans1 = v / a + (d - (v * v / 2.0 / a)) / v;
}
ans1 = ans1 + t;
if (ans2 <= ans1) {
printf("%.10f\n", ans1);
ans2 = ans1;
} else
printf("%.10f\n", ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double const e = 0.000001;
int main() {
int n, a, d;
cin >> n >> a >> d;
int prevv = 10000000;
double prevt = 0;
for (int i = 0; i < n; i++) {
int t, v;
cin >> t >> v;
double t1 = (double)v / a;
double s1 = a * t1 * t1 / 2;
double t2 = 0;
if (s1 - d > e) {
t1 = sqrt((2.0 * d) / a);
} else {
double s2 = d - s1;
t2 = s2 / v;
}
double tt = t1 + t2;
if (t + tt - prevt > e) {
prevt = t + tt;
prevv = v;
}
printf("%f\n", prevt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
double t, mv;
} bus[100010];
double dis, a;
int n;
double ans[100010];
int main() {
int i, j;
double t, tmp;
while (scanf("%d%lf%lf", &n, &a, &dis) != EOF) {
for (i = 0; i < n; i++) {
scanf("%lf%lf", &bus[i].t, &bus[i].mv);
}
for (i = 0; i < n; i++) {
t = sqrt(2 * dis * 1.0 / a);
if (a * t > bus[i].mv) {
t = bus[i].mv * 1.0 / a;
tmp = bus[i].mv * bus[i].mv * 1.0 / (2 * a);
t += (dis - tmp) * 1.0 / bus[i].mv;
}
ans[i] = t + bus[i].t;
}
for (i = 1; i < n; i++) {
if (ans[i] < ans[i - 1]) ans[i] = ans[i - 1];
}
for (i = 0; i < n; i++) {
printf("%.10lf\n", ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double a, d, t, v, z = 0.0;
scanf("%d%lf%lf", &n, &a, &d);
while (n--) {
scanf("%lf%lf", &t, &v);
if (d > v * v / 2 / a)
t += v / a + d / v - v / 2 / a;
else
t += sqrt(2 * d / a);
z = max(z, t);
printf("%.6lf\n", z);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, d;
cin >> n >> a >> d;
vector<int> t(n), v(n);
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) cin >> t[i] >> v[i];
double p, q, r;
vector<double> s;
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) {
double r = double(v[i]) / a;
p = sqrt(2. * double(d) / a);
if (r < p) {
q = (double(d) - 0.5 * a * r * r) / v[i] + r;
s.push_back(q + t[i]);
} else {
s.push_back(p + t[i]);
}
}
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) {
if (i > 0 && s[i] <= s[i - 1]) s[i] = s[i - 1];
cout.setf(ios::fixed, ios::floatfield);
cout.precision(9);
cout << s[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
const int INF = 1e9 + 7;
const int MAXN = int(2e5 + 7);
int n;
double t, v, a, d;
double last = INF;
int main() {
scanf("%d%lf%lf", &n, &a, &d);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &t, &v);
double ti = v / a;
double second = a * ti * ti / 2;
if (second >= d)
ti = sqrt(2 * d / a);
else
ti += (d - second) / v;
if (last == INF) last = ti + t;
last = max(ti + t, last);
printf("%.6f\n", last);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.