Problem:
Score : 1000 points

Problem Statement

You are given a sequence a = \{a_1, ..., a_N\} with all zeros, and a sequence b = \{b_1, ..., b_N\} consisting of 0 and 1. The length of both is N.

You can perform Q kinds of operations. The i-th operation is as follows:

Replace each of a_{l_i}, a_{l_i + 1}, ..., a_{r_i} with 1.

Minimize the hamming distance between a and b, that is, the number of i such that a_i \neq b_i, by performing some of the Q operations.

Constraints

1 \leq N \leq 200,000

b consists of 0 and 1.

1 \leq Q \leq 200,000

1 \leq l_i \leq r_i \leq N

If i \neq j, either l_i \neq l_j or r_i \neq r_j.

Input

Input is given from Standard Input in the following format:

N
b_1 b_2 ... b_N
Q
l_1 r_1
l_2 r_2
:
l_Q r_Q

Output

Print the minimum possible hamming distance.

Sample Input 1

3
1 0 1
1
1 3

Sample Output 1

1

If you choose to perform the operation, a will become \{1, 1, 1\}, for a hamming distance of 1.

Sample Input 2

3
1 0 1
2
1 1
3 3

Sample Output 2

0

If both operations are performed, a will become \{1, 0, 1\}, for a hamming distance of 0.

Sample Input 3

3
1 0 1
2
1 1
2 3

Sample Output 3

1

Sample Input 4

5
0 1 0 1 0
1
1 5

Sample Output 4

2

It may be optimal to perform no operation.

Sample Input 5

9
0 1 0 1 1 1 0 1 0
3
1 4
5 8
6 7

Sample Output 5

3

Sample Input 6

15
1 1 0 0 0 0 0 0 1 0 1 1 1 0 0
9
4 10
13 14
1 7
4 14
9 11
2 6
7 8
3 12
7 13

Sample Output 6

5

Sample Input 7

10
0 0 0 1 0 0 1 1 1 0
7
1 4
2 5
1 3
6 7
9 9
1 5
7 9

Sample Output 7

1

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
using namespace std;
constexpr int inf =1e9;
struct segtree{
    int n;
    vector<int> dat;
    vector<int> lazy;
    segtree(int _n):n(_n),
    dat(4*n, -inf),
    lazy(4*n, 0){}

    int q(int n, int a, int b, int l, int r){
        if(r<l || r<a || b<l) return -inf;
        if(l<=a && b<=r) return dat[n];
        if(lazy[n]){
            for(int j : {2*n, 2*n+1}){
                dat[j]+=lazy[n];
                lazy[j]+=lazy[n];
            }
            lazy[n] = 0;
        }
        return max(q(2*n, a, (a+b)/2, l, r), q(2*n+1, (a+b)/2+1, b, l, r));
    }
    int qq(int l, int r){
        return q(1, 0, n-1, l, r);
    }
    void u(int n, int a, int b, int l, int r, int val){
        if(r<l ||r<a || b<l) return;
        if(l<=a && b<=r){
            dat[n]+=val;
            lazy[n]+=val;
            return;
        }
        if(lazy[n]){
            for(int j : {2*n, 2*n+1}){
                dat[j]+=lazy[n];
                lazy[j]+=lazy[n];
            }
            lazy[n] = 0;
        }
        u(2*n, a, (a+b)/2, l, r, val);
        u(2*n+1, (a+b)/2+1, b, l, r, val);
        dat[n] = max(dat[2*n], dat[2*n+1]);
    }
    void uu(int l, int r, int val){
        u(1, 0, n-1, l, r, val);
    }
};

using ll = long long;

signed main()
{
    #ifdef LOCAL_RUN
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int TTT; cin >>TTT;
    while(TTT--){
    #endif // LOCAL_RUN

    int n, q; cin >> n;
    vector<int> a(n);
    for(auto &e:a) cin >> e;
    cin >> q;
    vector<vector<int> > qs(n+1);
    for(int i=0;i<q;++i){
        int a, b;
        cin >> a >> b;
        --a; --b;
        qs[a].push_back(b);
    }
    segtree st(n+5);
    auto add_val = [&](int i, int v){
        int old = st.qq(i, i);
        if(v>old){
            st.uu(i, i, v-old);
        }
    };
    add_val(0, 0);
    for(int i=0;i<n;++i){
        // check updates
        for(int j : qs[i]){
            add_val(j+1, st.qq(0, j));
        }
        if(a[i] == 0){
            st.uu(0, i, 1);
        } else {
            st.uu(i+1, n+1, 1);
        }
        //cerr << i << " : " << st.qq(0, n+1) << "\n";
    }
    int ans = st.qq(0, n+1);
    ans = n-ans;
    cout << ans << "\n";


    #ifdef LOCAL_RUN
    }
    #endif // LOCAL_RUN
    return 0;
}