#include<bits/stdc++.h>
using namespace std;
     
#define int long long
typedef pair<int, int> Pii;
     
template <typename T,typename E>
struct SegmentTree{
  using F = function<T(T,T)>;
  using G = function<T(T,E)>;
  using H = function<E(E,E)>;
  using P = function<E(E,size_t)>;
  int n;
  F f;
  G g;
  H h;
  T ti;
  E ei;
  P p;
  vector<T> dat;
  vector<E> laz;
  SegmentTree(int n_,F f,G g,H h,T ti,E ei,
    	      P p=[](E a,size_t b){b++;return a;}):
    f(f),g(g),h(h),ti(ti),ei(ei),p(p){
    init(n_);
  }
  void init(int n_){
    n=1;
    while(n<n_) n*=2;
    dat.assign(2*n-1,ti);
    laz.assign(2*n-1,ei);
  }
  void build(int n_, vector<T> v){
    for(int i=0;i<n_;i++) dat[i+n-1]=v[i];
    for(int i=n-2;i>=0;i--)
      dat[i]=f(dat[i*2+1],dat[i*2+2]);
  }
  inline void eval(int len,int k){
    if(laz[k]==ei) return;
    if(k*2+1<n*2-1){
      laz[k*2+1]=h(laz[k*2+1],laz[k]);
      laz[k*2+2]=h(laz[k*2+2],laz[k]);
    }
    dat[k]=g(dat[k],p(laz[k],len));
    laz[k]=ei;
  }
  T update(int a,int b,E x,int k,int l,int r){
    eval(r-l,k);
    if(r<=a||b<=l) return dat[k];
    if(a<=l&&r<=b){
      laz[k]=h(laz[k],x);
      return g(dat[k],p(laz[k],r-l));
    }
    return dat[k]=f(update(a,b,x,k*2+1,l,(l+r)/2),
    		    update(a,b,x,k*2+2,(l+r)/2,r));
  }
  T update(int a,int b,E x){
    return update(a,b,x,0,0,n);
  }
  T query(int a,int b,int k,int l,int r){
    eval(r-l,k);
    if(r<=a||b<=l) return ti;
    if(a<=l&&r<=b) return dat[k];
    T vl=query(a,b,k*2+1,l,(l+r)/2);
    T vr=query(a,b,k*2+2,(l+r)/2,r);
    return f(vl,vr);
  }
  T query(int a,int b){
    return query(a,b,0,0,n);
  }
  void update(int k,T x){
    query(k,k+1);//evaluate
    k+=n-1;
    dat[k]=x;
    while(k){
      k=(k-1)/2;
      dat[k]=f(dat[k*2+1],dat[k*2+2]);
    }
  }
};
      
signed main(){
  int N;
  cin >> N;

  vector<int> b(N);
  for ( int i = 0; i < N; i++ ) cin >> b[i];

  vector<int> cum(N, 0);
  cum[0] = b[0];
  for ( int i = 1; i < N; i++ ) cum[i] = cum[i-1]+b[i];     

  int Q;
  cin >> Q;

  vector<Pii> lr(Q);  
  for ( int i = 0; i < Q; i++ ) cin >> lr[i].first >> lr[i].second;

  sort(lr.begin(), lr.end());

  SegmentTree<int, int>::F f=[](int a,int b){return max(a,b);};
  SegmentTree<int, int>::G g=[](int a,int b){return a+b;};
  const int INF = 1e9;
  SegmentTree<int, int> seg(N+1,f,g,g,-INF,0);
  seg.update(0, 0);
  vector<int> dp(N+1, -INF);
  dp[0] = 0;

  int now = 0;
  for ( int i = 0; i < Q; i++ ) {
    //[l, r)にしたいのでこうしてる
    int l = lr[i].first-1, r = lr[i].second;
    //遷移してない分をここでやってる
    while ( now < l ) {
      dp[now+1] = max(dp[now+1], dp[now]+(!b[now]));
      now++;
    }

    //dp[r] = max(dp[r], l<=i<r max(dp[i]+cum[r-1]-cum[i-1]))となる
    //そこで[l, r)の最大をsegmenttreeを使って求めて高速化をする
    //dp[i]-cum[i-1]をsegtreeの要素とすることで簡単に求められる
    dp[r] = max(dp[r], seg.query(l, r)+cum[r-1]);
    dp[r] = max(dp[r], dp[l]+cum[r-1]-cum[l-1]);
    //dp[r]が更新されたのでsegtreeをdp[r]-cum[r-1]でupdate
    if ( seg.query(r, r+1) < dp[r]-cum[r-1] )
      seg.update(r, dp[r]-cum[r-1]);
  }
  //最後の遷移してない分
  while ( now < N ) {
    dp[now+1] = max(dp[now+1], dp[now]+(!b[now]));
    now++;
  }

  //全体から最大のマッチ数を答えとして出力
  cout << N-dp[N] << endl;
     
  return 0;
}


Measured memory_bytes: 18304