#pragma GCC optimize(O2)
#include<bits/stdc++.h>
#define int long long 
using namespace std;

template<class Info, class Tag>
struct LSGT {
#define l(p) (p << 1)
#define r(p) (p << 1 | 1)
    int n;
    std::vector<Info> info;
    std::vector<Tag> tag;
    LSGT() {}
    LSGT(int _n, Info _v = Info()) {
        init(_n, _v);
    }
    template<class T>
    LSGT(std::vector<T> _init) {
        init(_init);
    }
    void init(int _n, Info _v = Info()) {
        init(std::vector(_n, _v));
    }
    template<class T>
    void init(std::vector<T> _init) {
        n = _init.size();
        info.assign(4 << std::__lg(n), Info());
        tag.assign(4 << std::__lg(n), Tag());
        auto build = [&](auto self, int p, int l, int r) {
            if (r - l == 1) {
                info[p] = _init[l];
                return;
            }
            int m = l + r >> 1;
            self(self, l(p), l, m);
            self(self, r(p), m, r);
            pull(p);
        };
        build(build, 1, 0, n);
    }
    void pull(int p) {
        info[p] = info[l(p)] + info[r(p)];
    }
    void apply(int p, const Tag &v, int len) {
        info[p].apply(v, len);
        tag[p].apply(v);
    }
    void push(int p, int len) {
        apply(l(p), tag[p], len / 2);
        apply(r(p), tag[p], len - len / 2);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = l + r >> 1;
        push(p, r - l);
        if (x < m) {
            modify(l(p), l, m, x, v);
        } else {
            modify(r(p), m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }
    Info query(int p, int l, int r, int x, int y) {
        if (l >= y or r <= x) {
            return Info();
        }
        if (l >= x and r <= y) {
            return info[p];
        }
        int m = l + r >> 1;
        push(p, r - l);
        return query(l(p), l, m, x, y) + query(r(p), m, r, x, y);
    }
    Info query(int l, int r) {
        return query(1, 0, n, l, r);
    }
    void Apply(int p, int l, int r, int x, int y, const Tag &v) {
        if (l >= y or r <= x) {
            return;
        }
        if (l >= x and r <= y) {
            apply(p, v, r - l);
            return;
        }
        int m = l + r >> 1;
        push(p, r - l);
        Apply(l(p), l, m, x, y, v);
        Apply(r(p), m, r, x, y, v);
        pull(p);
    }
    void Apply(int l, int r, const Tag &v) {
        return Apply(1, 0, n, l, r, v);
    }
#undef l(p)
#undef r(p)
};

struct Tag {
    int add1,add2;
    Tag(int _add1=0,int _add2=0):add1(_add1),add2(_add2){}
    void apply(Tag t) {
        add1=(add1+t.add1);
        add2=(add2+t.add2);
    }
};
struct Info {
    int sum = 0,num0=0;
    void apply(Tag t, int len) {
        sum = (sum  + 1LL * t.add1 * len);
        num0=(num0 + 1LL * t.add2 * len);
    }
};
Info operator+(Info a, Info b) {
    Info c;
    c.sum = (a.sum + b.sum);
    c.num0=(a.num0+b.num0);
    return c;
}


void solve(){
    int n,q;cin>>n>>q;
    vector<int>a(n+1);
    for(int i=1;i<=n;i++) cin>>a[i];        
    sort(a.begin()+1,a.end());
    int mx=0,ans=0,z=0;
    vector<int>li,hash;
    for(int i=1;i<=n;i++){
        if(a[i]<0){  
            ans+=abs(a[i]);
        } 
        if(a[i]>0){ 
            li.push_back(a[i]);
            z++;
        }
    }
    vector<pair<int,int>>qu(1+1);
    auto b=a;
    for(int i=0;i<q;i++){
        int pos,val;cin>>pos>>val;
        qu[i]={pos,val};
        b[pos]=val;
        if(b[pos]>0) li.push_back(b[pos]);
    }
    sort(li.begin(),li.end());
    li.erase(unique(li.begin(),li.end()),li.end());
    auto idx=[&](int x)->int{
        auto pos=lower_bound(li.begin(),li.end(),x);
        int id=pos-li.begin()+1;
        //cout<<id<<"+\n";
        // if(pos==li.end()){
        //     cout<<"error\n";
        // }
        return id;
    };
    vector<Info>init(li.size()+10);
    for(int i=1;i<=n;i++){
        if(a[i]>0){
            auto pos=idx(a[i]);
            //cout<<pos<<" \n";
            init[pos].sum+=a[i];
            init[pos].num0=0;
        }
    }
    LSGT<Info,Tag>sgt(init);
    //cout<<"DEBUG: -------------------\n";
    for(int i=1;i<=li.size();i++){
        auto que=sgt.query(i,i+1);
        if(que.sum==0) sgt.Apply(i,i+1,Tag(0,1));
    }
    // for(int i=0;i<=li.size();i++){
    //     auto que=sgt.query(i,i+1);
    //     cout<<que.sum<<" "<<que.num0<<"\n";
    // }
    // cout<<"DEBUG: -------------------\n";
    for(int i=0;i<q;i++){
        auto [pos,val]=qu[i];
        int id1,id2;
        if(a[pos]>0)id1=idx(a[pos]);
        if(val>0)id2=idx(val);
        if(a[pos]>=0&&val>=0){
            sgt.Apply(id1,id1+1,Tag(-a[pos],1));
            sgt.Apply(id2,id2+1,Tag(val,-1));
            if(a[pos]>0&&val>0){

            }
            if(a[pos]==0&&val>0){
                z++;
            }
            if(a[pos]>0&&val==0){
                z--;
            }
            if(a[pos]==0&&val==0){

            }
        }
        if(a[pos]<0&&val<0){
            ans-=abs(a[pos]);
            ans+=abs(val);
        }
        if(a[pos]>=0&&val<=0){
            sgt.Apply(id1,id1+1,Tag(-a[pos],1));
            ans+=abs(val);
            if(a[pos]>0&&val<0){
                z--;
            }
            if(a[pos]==0&&val<0){
                
            }
            if(a[pos]>0&&val==0){
                z--;
            }
            if(a[pos]==0&&val==0){

            }
        }
        if(a[pos]<0&&val>0){
            sgt.Apply(id2,id2+1,Tag(val,-1));
            ans-=abs(a[pos]);
            z++;
        }
        a[pos]=val;
        int l=0,r=li.size()+1;
        while(l+1!=r){
            int mid=l+r>>1;
            auto que=sgt.query(1,mid+1).sum;
            if(que>=ans) r=mid;
            else l=mid;
        }
        //cout<<r-sgt.query(1,r+1).num0<<"\n";
        //cout<<"DEBUG: -------------------\n";    
        //cout<<"l:"<<l<<"ans:"<<max(0LL,l-1-sgt.query(1,l).num0)+(z!=0)<<" \n";
        // for(int i=1;i<=li.size();i++){
        //     auto que=sgt.query(i,i+1);
        //     cout<<que.sum<<" "<<que.num0<<"\n";
        // }
        // cout<<"DEBUG: -------------------\n";
        int tem=0;
        tem=max(0LL,r-1-sgt.query(1,r).num0);
        cout<<tem+(z!=0)<<"\n";
     }
}
                   
signed main(){
   ios::sync_with_stdio(false);
   cin.tie(nullptr);cout.tie(nullptr);
   int T=1; 
   //cin>>T;
   while(T--){
      solve();
   }
   return 0;
}