#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

#define REP(i,n) for(ll i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#define PRINTF(format, ...) printf(format, __VA_ARGS__)

#define MOD 1000000007
#define INF 1000000000
#define MAX_N 500010

ll N;
string S;
vector<ll> group[MAX_N];
vector<ll> comp;

ll group_ind = 0;
// i 番目を見ている場合の最大値を返す
// flag: 1 ビット目 : 左から取れるなら 1 / 2 ビット目 : 自分の取り分が減っているなら 1
ll dfs(ll i, ll flag) {
    if(i >= group[group_ind].size()) { return 0; }
    // flag 解析
    int isLeft;    // 左から取れる
    int isDec;     // 自分の取り分が減っている
    if(((flag >> 1) & 1) == 1) { isLeft = 1; }
    else { isLeft = 0; }
    if((flag & 1) == 1) { isDec = 1; }
    else { isDec = 0; }

    ll cand1 = 0, cand2 = 0, cand3 = 0, cand4 = 0;
    if(i == 0) {
        cand1 = dfs(i+1, 1) + group[group_ind][i] - isDec;  // 右から全取り
        cand2 = dfs(i+1, 2);                        // 取らず
    }
    else if(i == group[group_ind].size() - 1) {
        // 右端なら左から取るしかない
        if(isLeft == 1) {
            cand1 = dfs(i+1, 0) + group[group_ind][i] - isDec;  // 左から全取り
            cand2 = dfs(i+1, 2);    // 取らず
        }
    }
    else if(group[group_ind][i] == 1) {
        if(isDec == 1) {
            cand1 = dfs(i+1, 0);
        } else {
            // 左から取る
            if(isLeft == 1) { cand1 = dfs(i+1, 0) + group[group_ind][i]; }
            // 右から取る
            cand2 = dfs(i+1, 1) + group[group_ind][i];
            // 取らず
            cand3 = dfs(i+1, 2);
        }
    } else {
        if(isLeft == 1) {
            cand1 = dfs(i+1, 0) + group[group_ind][i] - isDec;      // 左から全取り
            cand2 = dfs(i+1, 2) + group[group_ind][i] - 1 - isDec;  // 左から取って 1 残す
        }
        cand3 = dfs(i+1, 1) + group[group_ind][i] - isDec;          // 右から全取り
        cand4 = dfs(i+1, 2);          // 取らず
    }
    return max( max(cand1, cand2), max(cand3, cand4) );
}

ll dp[MAX_N][4];

int main()
{
    cin >> N >> S;
    // 1 の連続を圧縮
    ll cons = 0;
    REP(i, N) {
        if(S[i] == '1') {
            cons++;
        } else {
            if(cons > 0) {
                comp.push_back(cons);
                cons = 0;
            }
            comp.push_back(0);
        }
    }
    if(cons > 0) {
        comp.push_back(cons);
        cons = 0;
    }
    ll ind = 0;
    {
        ll zero = 0;
        // 0 の連続で区切ってグループ化
        REP(i, comp.size()) {
            if(comp[i] == 0) {
                zero++;
                if(zero > 1 && group[ind].size() > 0) {
                    ind++;
                    zero = 0;
                }
            } else {
                group[ind].push_back(comp[i]);
                zero = 0;
            }
        }
    }
    if(group[ind].size() > 0) { ind++; }


    // FIXME; group[ind].size() == 1 が入ってしまうのでうまく無視すること

    // 各グループの最大値を求める
    ll ans = 0;
    ll ofs = 0;
    ZERO(dp);
    REP(j, ind) {
        if(group[j].size() > 1) {
#if 0
            printf("group %lld: ", j);
            REP(i, group[j].size()) {
                printf("%lld ", group[j][i]);
            }
            printf("\n");
#endif
            group_ind = j;
#if 0
            ll tmp = dfs(0, 0);
#else
            for(ll i = ofs + group[group_ind].size() - 1; i >= ofs; --i) {
                for(int flag = 0; flag < 3; ++flag) {
                    // flag 解析
                    int isLeft;    // 左から取れる
                    int isDec;     // 自分の取り分が減っている
                    if(((flag >> 1) & 1) == 1) { isLeft = 1; }
                    else { isLeft = 0; }
                    if((flag & 1) == 1) { isDec = 1; }
                    else { isDec = 0; }

                    ll cand1 = 0, cand2 = 0, cand3 = 0, cand4 = 0;
                    ll val_ind = i - ofs;
                    if(i == ofs) {
                        cand1 = dp[i+1][1] + group[group_ind][val_ind] - isDec;  // 右から全取り
                        cand2 = dp[i+1][2];                        // 取らず
                    }
                    else if(i == ofs + group[group_ind].size() - 1) {
                        // 右端なら左から取るしかない
                        if(isLeft == 1) {
                            cand1 = dp[i+1][0] + group[group_ind][val_ind] - isDec;  // 左から全取り
                            cand2 = dp[i+1][2];    // 取らず
                        }
                    }
                    else if(group[group_ind][val_ind] == 1) {
                        if(isDec == 1) {
                            cand1 = dp[i+1][0];
                        } else {
                            // 左から取る
                            if(isLeft == 1) { cand1 = dp[i+1][0] + group[group_ind][val_ind]; }
                            // 右から取る
                            cand2 = dp[i+1][1] + group[group_ind][val_ind];
                            // 取らず
                            cand3 = dp[i+1][2];
                        }
                    } else {
                        if(isLeft == 1) {
                            cand1 = dp[i+1][0] + group[group_ind][val_ind] - isDec;      // 左から全取り
                            cand2 = dp[i+1][2] + group[group_ind][val_ind] - 1 - isDec;  // 左から取って 1 残す
                        }
                        cand3 = dp[i+1][1] + group[group_ind][val_ind] - isDec;          // 右から全取り
                        cand4 = dp[i+1][2];          // 取らず
                    }
                    dp[i][flag] = max( max(cand1, cand2), max(cand3, cand4) );
                    //printf("  dp[%lld][%d] = %lld\n", i, flag, dp[i][flag]);
                    //printf("    cand: %lld %lld %lld %lld\n", cand1, cand2, cand3, cand4);
                }
            }
            ll tmp = dp[ofs][0];
            //printf("tmp : %lld\n", tmp);
            ofs += group[group_ind].size();
#endif
            ans += tmp;
        }
    }
    printf("%lld\n", ans);
    return 0;
}


Measured memory_bytes: 34164