Problem:
イルミネーション 2
JOI 高校の生徒である葵は，文化祭で廊下に電飾を飾ることにした．
電飾は，
N
個の電球を東西方向に一列に並べて作る．電球には西側から順に
1
から
N
までの番号が付けられている．各電球にはオンとオフの
2
つの状態があり，はじめ電球はすべてオフの状態である．
葵が目標とする電飾の模様は数列
A
1
, A
2
, ..., A
N
で表され，
A
i
= 1
のときは電球
i
をオンに，
A
i
= 0
のときはオフにしたい．葵はできるだけ短い時間でこの模様にしようと考えた．
葵は最初に次の操作を
1
回だけ行うことができるが，行わなくてもよい．
西側の端から連続した区間の電球をオンにする．すなわち，
1
以上
N
以下の整数
r
を
1
つ選び，電球
1, 2, ... , r
をオンにする．
この操作を行うのにかかる時間は無視できる．
その後，次の操作を何回でも行うことができる．
電球を
1
つ選び，その電球の状態を変更する (オンならばオフに，オフならばオンにする)．
この操作を行うには
1
回につき
1
分かかる．
電球の個数，目標とする電飾の模様が与えられたとき，葵が目標の模様にするのに最短で何分かかるかを求めるプログラムを作成せよ．
制約
1 ≦ N ≦ 200000
．
A
i
は
0
か
1
のいずれかである (
1 ≦ i ≦ N
)．
入力される値はすべて整数である．
入力
入力は以下の形式で標準入力から与えられる．
N
A
1
A
2
…
A
N
出力
標準出力に，目標の模様にするのに最短で何分かかるかを
1
行で出力せよ．
入出力例
入力例 1
6
0 1 1 0 0 1
出力例 1
2
例えば，葵は最初に
r = 3
を選び，電球
1, 2, 3
をオンにする．この操作にかかる時間は
0
分である．その後，電球
1
をオンからオフに，電球
6
をオフからオンに状態を変更する．この操作にはそれぞれ
1
分ずつ合計で
2
分かかる．
2
分未満で目標の模様にすることはできないので，
2
を出力する．
入力例 2
4
0 0 0 1
出力例 2
1
この入力例では，葵は最初の操作は行わない．その後，電球
4
をオフからオンに状態を変更する．この操作には
1
分かかり，
1
分未満で目標の模様にすることはできないので，
1
を出力する．
入力例 3
4
1 1 1 1
出力例 3
0
この入力例では，葵は最初に
r = 4
を選び電球
1, 2, 3, 4
をオンにすることで，目標の模様にすることができる．この操作にかかる時間は
0
分であるので，
0
を出力する．
入力例 4
15
1 0 0 0 0 1 1 1 0 1 0 0 1 0 1
出力例 4
6
情報オリンピック日本委員会
作 『日本情報オリンピック 第1回 女性部門』

Submitted solutions:

code_snippet: #include <iostream>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <cstdlib>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

int main(){
  int n;
  cin >> n;
  vector<int> a(n);
  rep(i,n){
    cin >> a[i];
  }
  vector<int> cnt(n+1);
  cnt[0]=0;
  rep(i,n){
    cnt[i+1]=cnt[i]+a[i];
  }
  int res=n;
  for(int i=0;i<=n;i++){
    res = min(res,i+cnt[n]-2*cnt[i]);
  }
  cout << res << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 4692
final_rank: 4

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int N;
    cin >> N;

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

    // 不選擇將前面的部分電燈一次性全部打開的情況下，計算所需的切換次數
    int changes = 0;
    for (int i = 0; i < N; ++i) {
        if (A[i] == 1) {
            changes++;
        }
    }
    int min_changes = changes;

    // 選擇將前面的部分電燈一次性全部打開的情況
    int current_on = 0;
    for (int r = 0; r < N; ++r) {
        if (A[r] == 1) {
            current_on++;
        }
        int new_changes = (r + 1 - current_on) + (changes - current_on);
        min_changes = min(min_changes, new_changes);
    }

    cout << min_changes << endl;

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3612
final_rank: 10

code_snippet: #include <bits/stdc++.h>
using namespace std;

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

    // 前処理
    vector<int> left(N+1, 0), right(N+1, 0);
    for (int i = 0; i < N; ++i) {
        left[i+1] = left[i] + (A[i] == 0);
        right[i+1] = right[i] + (A[N-i-1] == 1);
    }

    // 最適化
    int res = N;  // 理論上の上限値
    for (int i = 0; i <= N; ++i) {
        res = min(res, left[i] + right[N-i]);
    }
    cout << res << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 5440
final_rank: 5

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main(){
    int n, a, ruiz[200010], ruio[200010];
    cin >> n;
    ruiz[0] = 0;
    ruio[0] = 0;
    for(int i=1;i<=n;i++){
        cin >> a;
        ruiz[i] = ruiz[i-1];
        if(a == 0) ruiz[i]++;
        ruio[i] = ruio[i-1]+a;
    }
    int mi = n;
    for(int i=0;i<=n;i++) mi = min(mi, ruiz[i]+ruio[n]-ruio[i]);
    cout << mi << endl;
    return(0);
}
accuracy: 1
time_ms: 20
memory_kb: 4672
final_rank: 12

code_snippet: #include <iostream>
using namespace std;
int as[200002];
int main(){
	// your code goes here
	int n;
	cin>>n;
	int ans=0;
	int m1=0;
	for(int i=0;i<n;i++){
		cin>>as[i];
		m1+=as[i];
	}
	ans=m1;
	for(int i=0;i<n;i++){
		if(as[i]==1){
			m1--;
		}else{
			m1++;
		}
		if(ans>m1)ans=m1;
	}
	cout<<ans<<endl;
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3872
final_rank: 11

code_snippet: #include <iostream>

using namespace std;

int main()
{
	int N, s = 0, t = 0; cin >> N;
	for (int i = 0, a, r = 1; i < N; ++i, ++r) {
		cin >> a;
		s += a;
		auto u = r - 2 * s;
		if (t > u) t = u;
	}
	cout << s + t << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3420
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;

using ll = long long;
#define all(A) A.begin(),A.end()
using vll = vector<ll>;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
using Graph = vector<vector<pair<ll, ll>>>;


int main() {
	ll N;
	cin>>N;
	vll A(N);
	vll S(N+1,0);
	ll P;
	rep(i,N){
		cin>>A[i];
		S[i+1]=S[i]+A[i];
	}
	P=S[N];
	ll an=1e18;
	rep(i,N+1){
		an=min(an,P-S[i]+(i)-S[i]);
	}
	cout<<an<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 6236
final_rank: 7

code_snippet: #include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <vector>
#include <numeric>
#include <algorithm>
#include <queue>
#include <string>
#include <random>
#include <array>
#include <climits>
#include <map>
#include <cassert>
#include <stack>
#include <iomanip>
#include <cfloat>
#include <fstream>

int main() {
	int n; std::cin >> n;
	std::vector<int> dest(n);
	for (auto& a : dest) {
		std::cin >> a;
	}
	int on = std::accumulate(dest.begin(), dest.end(), 0);
	int off = 0;
	int result{ on };
	for (auto i = 0; i < n; ++i) {
		on -= dest[i];
		off += 1 - dest[i];
		result = std::min(result, on + off);
	}
	std::cout << result << '\n';
}
accuracy: 1
time_ms: 10
memory_kb: 3892
final_rank: 2

code_snippet: #include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
using namespace std;
const long long MOD1 = 1000000007;
const long long MOD2 = 998244353;
#define logn long
#define lnog long
#define lgon long
#define itn int
typedef long long ll;
typedef pair<long long, long long> P;
const long logn INF = 1e18;
//Data stracture
//区間最小値を求めるセグ木
template <typename T>
struct RMQ {
    const T INF = 2147483647;
    int N; //number of leaves
    vector<T> dat; //perfect binary tree

    RMQ(int n_) : N(), dat(n_ * 4, INF) { //The number of leaves can be displayed by the formula, 2 ^ x.
        int x = 1;
        while (n_ > x) {
            x *= 2;
        }
        N = x;
    }

    void update(long long i, T x) {
        i += N - 1;
        dat.at(i) = x;
        while (i > 0) {
            i = (i - 1) / 2; //parent
            dat.at(i) = min(dat.at(i * 2 + 1), dat.at(i * 2 + 2));
        }
    }

    //the minimum element of [a, b)
    T query(long long a, long long b) {
        return query_sub(a, b, 0, 0, N);
    }
    T query_sub(long long a, long long b, long long k, long long l, long long r) {
        if (r <= a || b <= l) {
            return INF;
        }
        else if (a <= l && r <= b) {
            return dat.at(k);
        }
        else {
            T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
            T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
            return min(vl, vr);
        }
    }
};
//prime_factorization : 素因数分解
vector<P> prime_factorization(long long N) {
    vector<P>A;
    long long tmp = N;
    for (long long i = 2; i * i <= N; i++) {
        if (tmp % i == 0) {
            A.push_back({ i, 0 });
            while (tmp % i == 0) {
                A.back().second++;
                tmp /= i;
            }
        }
    }
    if (tmp != 1) A.push_back({ tmp, 1 });
    return A;
}
//power : M^N(mod MOD)
long long power(long long N, long long M, long long MOD) {
    long long ans = 1;
    while (M > 0) {
        if (M & 1) {
            ans = ans * N % MOD;
        }
        N = N * N % MOD;
        M >>= 1;
    }
    return ans;
}
//Euler_phi : オイラー関数
long long Euler_phi(long long N) {
    vector<P>A = prime_factorization(N);
    for (long long i = 0; i < A.size(); i++) {
        N /= A[i].first;
    }
    for (long long i = 0; i < A.size(); i++) {
        N *= (A[i].first - 1);
    }
    return N;
}
//extgcd : 拡張ユークリッド互除法（返すのは gcd(A,B),AX + BY = GCD(A,B)）
long long extgcd(long long A, long long B, long long& X, long long& Y) {
    long long D = A;
    if (B != 0) {
        D = extgcd(B, A % B, Y, X);
        Y -= (A / B) * X;
    }
    else {
        X = 1; Y = 0;
    }
    return D;
}

//計算幾何
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
//Point : 点(x, y)(点の座標(x,y)、ベクトル演算(+,-,*,/)、ベクトルのノルム(norm)、大きさ(abs)、大小比較(<)、合同を保存(==))
class Point {
public:
    double x;
    double y;

    Point(double x = 0, double y = 0) : x(x), y(y) {}

    Point operator+(Point p) { return Point(x + p.x, y + p.y); }
    Point operator-(Point p) { return Point(x - p.x, y - p.y); }
    Point operator*(double a) { return Point(a * x, a * y); }
    Point operator/(double a) { return Point(x / a, y / a); }

    double abs() { return sqrt(norm()); }
    double norm() { return x * x + y * y; }

    bool operator<(const Point& p) const {
        return x != p.x ? x < p.x : y < p.y;
    }
    bool operator==(const Point& p) const {
        return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
    }
};
//Vector : ベクトル（配列のvectorと間違えぬように）
typedef Point Vector;
//Segment : 線分AB(点A, Bの座標を保存)
struct Segment {
    Point A;
    Point B;
};
//Line : 直線AB
typedef Segment Line;
//Circle : 円(中心点C、半径r を保存)
class Circle {
public:
    Point C;
    double r;
    Circle(Point C = Point(), double r = 0.0) : C(C), r(r) {}
};
//Polygon : 多角形（各頂点の点列で表す）
typedef vector<Point> Polygon;
//dot : ベクトルA, B の内積
double dot(Vector A, Vector B) {
    return A.x * B.x + A.y * B.y;
}
//cross : ベクトルA, B の外積
double cross(Vector A, Vector B) {
    return A.x * B.y - A.y * B.x;
}
//Projection : 射影(点pを通る、直線Sへの垂線の足の座標)
Point Projection(Segment S, Point p) {
    Vector base = S.B - S.A;
    double r = dot(p - S.A, base) / base.norm();
    return S.A + base * r;
}
//Reflection : 反射(直線Sに関して、点pと対称な点の座標)
Point Reflection(Segment S, Point p) {
    return p + (Projection(S, p) - p) * 2.0;
}
//isOrthogonal : 直交しているか？ <==> ベクトルA, B の内積は0か？
bool isOrthogonal(Vector A, Vector B) {
    return equals(dot(A, B), 0.0);
}
bool isOrthogonal(Point A1, Point A2, Point B1, Point B2) {
    return isOrthogonal(A1 - A2, B1 - B2);
}
bool isOrthogonal(Segment S1, Segment S2) {
    return equals(dot(S1.B - S1.A, S2.B - S2.A), 0.0);
}
//isParallel : 平行か？ <==> ベクトルA, B の外積は0か？
bool isParallel(Vector A, Vector B) {
    return equals(cross(A, B), 0.0);
}
bool isParallel(Point A1, Point A2, Point B1, Point B2) {
    return isParallel(A1 - A2, B1 - B2);
}
bool isParallel(Segment S1, Segment S2) {
    return equals(cross(S1.B - S1.A, S2.B - S2.A), 0.0);
}
//getDistance : 2点A,Bの距離
double getDistance(Point A, Point B) {
    return (A - B).abs();
}
//getDistanceLP : 直線Lと点Pの距離
double getDistanceLP(Line L, Point P) {
    return abs((cross(L.B - L.A, P - L.A))) / (L.B - L.A).abs();
}
//getDistanceSP : 線分Sと点Pの距離
double getDistanceSP(Segment S, Point P) {
    if (dot(S.B - S.A, P - S.A) < 0.0) return (P - S.A).abs();
    if (dot(S.A - S.B, P - S.B) < 0.0) return (P - S.B).abs();
    return getDistanceLP(S, P);
}
//定数定義
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
//ccw : 3点A,B,Cがこの順に反時計回りか？
int ccw(Point A, Point B, Point C) {
    Vector S = B - A, T = C - A;
    if (cross(S, T) > EPS) return COUNTER_CLOCKWISE; //反時計回り
    if (cross(S, T) < -EPS) return CLOCKWISE; //時計回り
    if (dot(S, T) < -EPS) return ONLINE_BACK; //C,A,Bの順で同一直線上にある
    if (S.norm() < T.norm()) return ONLINE_FRONT; //A,B,Cの順で同一直線上にある
    return ON_SEGMENT; //Cが線分AB上にある
}
//intersect : 線分AB, CDは交差するか？
bool intersect(Point A, Point B, Point C, Point D) {
    return (ccw(A, B, C) * ccw(A, B, D) <= 0 && ccw(C, D, A) * ccw(C, D, B) <= 0);
}
bool intersect(Segment S1, Segment S2) {
    return intersect(S1.A, S1.B, S2.A, S2.B);
}
//別のintersect : 円Cと直線Lが交差するかどうか
bool intersect(Circle C, Line L) {
    return (getDistanceLP(L, C.C) <= C.r);
}
//getDistance : 線分S1, S2 の距離もこの関数で導入
double getDistance(Segment S1, Segment S2) {
    if (intersect(S1, S2)) return 0.0;
    return min(min(getDistanceSP(S1, S2.A), getDistanceSP(S1, S2.B)), min(getDistanceSP(S2, S1.A), getDistanceSP(S2, S1.B)));
}//getCrossPoint : 線分S1, S2 の交点(線分AB, 線分CD の交点)
Point getCrossPoint(Segment S1, Segment S2) {
    Vector base = S2.B - S2.A;
    double d1 = abs(cross(base, S1.A - S2.A));
    double d2 = abs(cross(base, S1.B - S2.A));
    double T = d1 / (d1 + d2);
    return S1.A + (S1.B - S1.A) * T;
}
Point getCrossPoint(Point A, Point B, Point C, Point D) {
    Vector base = D - C;
    double d1 = abs(cross(base, A - C));
    double d2 = abs(cross(base, B - C));
    double T = d1 / (d1 + d2);
    return A + (B - A) * T;
}
//getCrossPoints : 円Cと直線Lの交点（2つ以下のため、pairで管理）
pair<Point, Point> getCrossPoints(Circle C, Line L) {
    assert(intersect(C, L));
    Vector pr = Projection(L, C.C);
    Vector e = (L.B - L.A) / (L.B - L.A).abs();
    double base = sqrt(C.r * C.r - (pr - C.C).norm());
    return make_pair(pr + e * base, pr - e * base);
}
//グラフを表す構造体
struct Graph {
    //辺を表す構造体
    //rev : 逆辺 (to, from) が G[to] の中で何番目の要素か
    //cap : 辺 (from, to) の容量
    struct Edge {
        long long rev, from, to, cap;
        Edge(long long r, long long f, long long t, long long c) :
            rev(r), from(f), to(t), cap(c) {}
    };

    //隣接リスト
    vector<vector<Edge>> list;

    //N : 頂点数
    Graph(long long N = 0) : list(N) {}

    //グラフの頂点数取得
    size_t size() {
        return list.size();
    }

    //Graph インスタンスを G として、
    // G.list[v] を G[v] と書けるようにしておく
    vector<Edge>& operator [] (long long i) {
        return list[i];
    }

    //辺 e = (u, v) の逆辺 (v, u) を取得する
    Edge& redge(const Edge& e) {
        return list[e.to][e.rev];
    }

    //辺 e = (u, v) に流量 f のフローを流す
    //e = (u, v) の流量が f だけ減少する
    //この時、逆辺 (v, u) の流量を増やす
    void run_flow(Edge& e, long long f) {
        e.cap -= f;
        redge(e).cap += f;
    }

    //頂点 from から頂点 to へ容量 cap の辺を張る
    //このとき to から from へも容量 0 の辺を張っておく
    void addedge(long long from, long long to, long long cap) {
        long long fromrev = (long long)list[from].size();
        long long torev = (long long)list[to].size();
        list[from].push_back(Edge(torev, from, to, cap));
        list[to].push_back(Edge(fromrev, to, from, 0));
    }
};
struct Ford_Fulkerson {
    static const int INF = 1 << 30;
    vector<long long> seen;

    Ford_Fulkerson() {}

    //残余グラフ上で s-t パスを見つける（DFS）
    //返り値は s-t パス上の容量の最小値（見つからなかったら 0）
    //f: s から v へ到達した過程の各辺の容量の最小値
    long long fodfs(Graph& G, long long v, long long t, long long f) {
        //終端 t に到達したらリターン
        if (v == t) return f;

        //DFS
        seen[v] = true;
        for (auto& e : G[v]) {
            if (seen[e.to]) continue;

            //容量 0 の辺は実際には存在しない
            if (e.cap == 0) continue;

            //s-t パスを探す
            //見つかったら flow はパス上の最小容量
            //見つからなかったら f = 0
            long long flow = fodfs(G, e.to, t, min(f, e.cap));

            //s-t パスが見つからなかったら次辺を試す
            if (flow == 0) continue;

            //辺 e に容量 flow のフローを流す
            G.run_flow(e, flow);

            //s-t パスを見つけたらパス上最小容量を返す
            return flow;
        }
        //s-t パスが見つからなかったことを示す
        return 0;
    }

    //グラフ G の s-t 間の最大流量を求める
    //ただしリターン時に G は残余グラフになる
    long long solve(Graph& G, long long s, long long t) {
        long long res = 0;

        //残余グラフに s-t パスがなくなるまで反復
        while (true) {
            seen.assign((long long)G.size(), 0);
            long long flow = fodfs(G, s, t, INF);

            //s-t パスが見つからなかったら終了
            if (flow == 0) return res;

            //答えを加算
            res += flow;
        }

        //no reach
        return 0;
    }
};
struct EDGE {
    long long to;
    long long cost;
};
void dijkstra(const vector<vector<EDGE>>& G, int s, vector<long long>& dis, vector<long long>& prev) {
    int N = G.size();
    dis.resize(N, INF);
    prev.resize(N, -1); // 初期化
    priority_queue<P, vector<P>, greater<P>> pq;
    dis[s] = 0;
    pq.emplace(dis[s], s);
    while (!pq.empty()) {
        P p = pq.top();
        pq.pop();
        int v = p.second;
        if (dis[v] < p.first) {
            continue;
        }
        for (auto& e : G[v]) {
            if (dis[e.to] > dis[v] + e.cost) {
                dis[e.to] = dis[v] + e.cost;
                prev[e.to] = v; // 頂点 v を通って e.to にたどり着いた
                pq.emplace(dis[e.to], e.to);
            }
        }
    }
}
//find : A 内に key のある位置（ないなら -1 ）
long long find(vector<long long>& A, long long key) {
    if (A.empty()) return -1;
    long long left = 0, right = A.size() - 1;
    while (left <= right) {
        long long mid = (left + right) / 2;
        if (A[mid] == key) return mid;
        else if (A[mid] < key) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}
void BFS(vector<vector<long long>>& G, long long s, vector<long long>& dist) {
    queue<long long>Q;
    dist[s] = 0; Q.push(s);
    while (!Q.empty()) {
        long long v = Q.front(); Q.pop();
        for (auto nv : G[v]) {
            if (dist[nv] == INF) {
                dist[nv] = dist[v] + 1;
                Q.push(nv);
            }
        }
    }
}
vector<int> string_to_bigint(string S) {
    int N = S.size(); // N = (文字列 S の長さ)
    vector<int> digit(N);
    for (int i = 0; i < N; ++i) {
        digit[i] = S[N - i - 1] - '0'; // 10^i の位の数
    }
    return digit;
}
string bigint_to_string(vector<int> digit) {
    int N = digit.size(); // N = (配列 digit の長さ)
    string str = "";
    for (int i = N - 1; i >= 0; --i) {
        str += digit[i] + '0';
    }
    return str;
}
vector<int> carry_and_fix(vector<int> digit) {
    int N = digit.size();
    for (int i = 0; i < N - 1; ++i) {
        // 繰り上がり処理 (K は繰り上がりの回数)
        if (digit[i] >= 10) {
            int K = digit[i] / 10;
            digit[i] -= K * 10;
            digit[i + 1] += K;
        }
        // 繰り下がり処理 (K は繰り下がりの回数)
        if (digit[i] < 0) {
            int K = (-digit[i] - 1) / 10 + 1;
            digit[i] += K * 10;
            digit[i + 1] -= K;
        }
    }
    // 一番上の桁が 10 以上なら、桁数を増やすことを繰り返す
    while (digit.back() >= 10) {
        int K = digit.back() / 10;
        digit.back() -= K * 10;
        digit.push_back(K);
    }
    // 1 桁の「0」以外なら、一番上の桁の 0 (リーディング・ゼロ) を消す
    while (digit.size() >= 2 && digit.back() == 0) {
        digit.pop_back();
    }
    return digit;
}
vector<int> multiplication(vector<int> digit_a, vector<int> digit_b) {
    int NA = digit_a.size(); // A の桁数
    int NB = digit_b.size(); // B の桁数
    vector<int> res(NA + NB - 1);
    for (int i = 0; i < NA; ++i) {
        for (int j = 0; j < NB; ++j) {
            res[i + j] += digit_a[i] * digit_b[j];
            // 答えの i+j の位に digit_a[i] * digit_b[j] を足す
        }
    }
    return carry_and_fix(res);
}
struct triple {
    long long a; long long b; long long c;
};
const long long MOD = (long long)2e18;
const int MAX_C = 61;
long long Com[MAX_C][MAX_C];
void calc_com() {
    memset(Com, 0, sizeof(Com));
    Com[0][0] = 1;
    for (int i = 1; i < MAX_C; ++i) {
        Com[i][0] = 1;
        for (int j = 1; j < MAX_C; ++j) {
            Com[i][j] = (Com[i - 1][j - 1] + Com[i - 1][j]) % MOD;
        }
    }
}
vector<long long> get_path(const vector<long long>& prev, long long t, const vector<long long>& dist) {
    vector<long long> path;
    for (int cur = t; cur != -1; cur = prev[cur]) {
        path.push_back(cur);
    }
    reverse(path.begin(), path.end()); // 逆順なのでひっくり返す
    return path;
}
long long calc = 0;
vector<long long> BFS_num(vector<vector<long long>>& G, long long s, vector<long long>& dist, vector<long long>& st, long long M) {
    vector<long long>D(M, 0);
    queue<long long>Q;
    long long ans = 0;
    dist[s] = 0; D[st[s]] = 1;  Q.push(s);
    while (!Q.empty()) {
        long long v = Q.front(); Q.pop();
        for (auto nv : G[v]) {
            if (dist[nv] == -1) {
                calc++;
                dist[nv] = dist[v] + 1;
                if (dist[nv] + st[s] == st[nv]) D[st[nv]]++;
                Q.push(nv);
            }
        }
    }
    return D;
}
//input_arr : 配列 A を入力
template <typename T>
void input_arr(vector<T>& A, long long N) {
    for (long long i = 0; i < N; i++) {
        cin >> A[i];
    }
}
string up_lo(string S) {
    for (long long i = 0; i < S.size(); i++) {
        if ('A' <= S[i] && S[i] <= 'Z') {
            S[i] = 'a' + (S[i] - 'A');
        }
        else if ('z' <= S[i] && S[i] <= 'z') {
            S[i] = 'A' + (S[i] - 'a');
        }
        else return "???";
    }
    return S;
}
int main() {
    long logn N; cin >> N;
    vector<long long>A(N); input_arr(A, N);
    vector<long long>B(N+1,0), C(N+1,0);
    for (long long i = 1; i <= N; i++) {
        if (A[i-1] == 0) B[i]++;
        else C[i]++;
    }
    for (long long i = 1; i <= N; i++) {
        B[i] += B[i - 1];
        C[i] += C[i - 1];
    }
    long long ans = INF;
    for (long long i = 0; i <= N; i++) {
        ans = min(ans, B[i] + C[N] - C[i]);
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 7876
final_rank: 9

code_snippet: #include<iostream>
#include<algorithm>    
#include<bitset>
#include<cassert>
#include<cctype>
#include<cmath>
#include<ctime>
#include<fstream>
#include<functional>
#include<map>
#include<math.h>
#include<queue>
#include<set>
#include<stack>
#include<stdio.h>
#include<string>
#include<tuple>
#include<vector>
//#include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define rep(i, x) for(ll i = 0; i < x; i++)
#define rep2(i, x) for(ll i = 1; i <= x; i++)
#define rep3(i, x, y) for(ll i = x; i < y; i++)
#define rep4(i, x) for(ll i = x - 1; i >= 0; i--)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define puts(x) cout << (x) << "\n"
using ll = long long;
using ld = long double;
using namespace std;
const ll INF = 1000000000000000000;
const int intINF = 1000000000;
const ll mod = 1000000007;
const ll MOD = 998244353;
const ld pi = 3.141592653589793238;
//const ld EPS = 1e-9;
typedef string::const_iterator State;
class ParseError {};

bool isprime(int p) {
	if (p == 1) return false;
	for (int i = 2; i < p; i++) {
		if (p % i == 0) return false;
	}
	return true;
}
ll gcd(ll a, ll b) {
	if (b == 0) { return a; }
	return gcd(b, a % b);
}
//ax + by = cが整数解をもつための必要十分条件は c が gcd(a,b) で割り切れること。
// 返り値: a と b の最大公約数
// ax + by = gcd(a, b) を満たす (x, y) が格納される
//main関数内に extGCD(a, b, x, y); でx, yに解が格納
ll extGCD(ll a, ll b, ll& x, ll& y) {
	if (b == 0) {
		x = 1;
		y = 0;
		return a;
	}
	ll d = extGCD(b, a % b, y, x);
	y -= a / b * x;
	return d;
}
ll lcm(ll a, ll b) {
	return a / gcd(a, b) * b;
}
ll keta(ll n) {
	ll res = 0;
	while (n >= 1) {
		res++;
		//res += n % 10;

		n /= 10;
	}
	return res;
}
ll modpow(ll x, ll y, ll m) {
	ll res = 1;
	while (y) {
		if (y % 2) { res *= x; res %= m; }
		x = x * x % m; y /= 2;
	}
	return res;
}

const int nCkMAX = 500000;
ll fac[nCkMAX], finv[nCkMAX], inv[nCkMAX];//n!、1/n!、1/n
// テーブルを作る前処理
void nCkinit(ll m) {
	fac[0] = fac[1] = 1;
	finv[0] = finv[1] = 1;
	inv[1] = 1;
	for (int i = 2; i < nCkMAX; i++) {
		fac[i] = fac[i - 1] * i % m;
		inv[i] = m - inv[m % i] * (m / i) % m;
		finv[i] = finv[i - 1] * inv[i] % m;
	}
}
// 二項係数計算
ll nCk(ll n, ll k, ll m) {
	if (n < k) return 0;
	if (n < 0 || k < 0) return 0;
	return fac[n] * (finv[k] * finv[n - k] % m) % m;
}
ll nCk2(ll n, ll k, ll m) {
	ll res = 1;
	for (int i = n - k + 1; i <= n; i++) {
		res *= i; res %= m;
	}
	for (int i = 1; i <= k; i++) {
		res *= modpow(i, m - 2, m); res %= m;
	}
	return res;
}
ll waru = 1;
ll nCk3(ll n, ll k, ll m) {
	ll res = 1;
	for (int i = n - k + 1; i <= n; i++) {
		res *= i; res %= m;
	}
	res *= waru; res %= MOD;
	return res;
}

//xorshift　from 「ビット演算 (bit 演算) の使い方を総特集！ 」
//1~6まで出したいときは
//xorshift() % 6 + 1
unsigned int xorshift() {
	static unsigned int tx = 123456789, ty = 362436069, tz = 521288629, tw = 88675123;
	unsigned int tt = (tx ^ (tx << 11));
	tx = ty; ty = tz; tz = tw;
	return (tw = (tw ^ (tw >> 19)) ^ (tt ^ (tt >> 8)));
}


//printf("%.10f\n", n);
typedef pair <ll, ll> P;
typedef pair <ld, ll> pp;
ll dx[4] = { 1, 0, -1, 0 }, dy[4] = { 0, 1, 0, -1 };


vector<ll> spf;
void smallest_prime_factors(ll n) {
	spf.resize(n + 1); spf[1] = 1;
	for (int i = 2; i <= n; i++) {
		if (!spf[i]) {
			for (int j = i; j < n; j += i) { spf[j] = i; }
		}
	}
}
std::map<int, int> high_speed_prime_factor(int n) {
	std::map<int, int> res;
	while (n != 1) {
		res[spf[n]]++;
		n /= spf[n];
	}
	return res;
}

////////////////////////////////struct
struct edge {
	ll to; ld cost;
};
struct Point {
	ll x, y;
};
bool operator<(const Point& a1, const Point& a2) {
	if (a1.x < a2.x) return true;
	if (a1.x > a2.x) return false;
	if (a1.y < a2.y) return true;
	return false;
}
struct status {
	/*ll a;
	ll b;
	ll c;
	ll ind;*/
	ll first;//d[映画]
	ll second;//映画
	ll kai;

	//bool operator<(const status& rhs) const { return c < rhs.c; };
	//bool operator>(const status& rhs) const { return c > rhs.c; };
	bool operator<(const status& rhs) const { return kai < rhs.kai; };
	bool operator>(const status& rhs) const { return kai > rhs.kai; };
};
void yesno(bool ok) {
	if (ok) { cout << "Yes\n"; }
	else { cout << "No\n"; }
}
//多倍長整数演算
//nCkを求めるときにnCkMAXとnCkinit



int main() {
	ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	//cout << fixed << setprecision(15);

	ll n; cin >> n;
	vector<ll>a(n + 2);
	rep2(i, n) { cin >> a[i]; }
	vector<ll>zero(n + 2), one(n + 2);
	rep2(i, n) {
		zero[i] = zero[i - 1];
		if (a[i] == 0) { zero[i]++; }
	}
	for (int i = n; i > 0; i--) {
		one[i] = one[i + 1];
		if (a[i] == 1) { one[i] ++; }
	}
	ll ans = INF;
	rep(i, n + 1) {
		ans = min(ans, zero[i] + one[i + 1]);
	}
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 7844
final_rank: 8

code_snippet: #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define drep(i,j,n) for(int i=0;i<(int)(n-1);i++)for(int j=i+1;j<(int)(n);j++)
#define trep(i,j,k,n) for(int i=0;i<(int)(n-2);i++)for(int j=i+1;j<(int)(n-1);j++)for(int k=j+1;k<(int)(n);k++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yes(ans) if(ans)printf("yes\n");else printf("no\n")
#define Yes(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YES(ans) if(ans)printf("YES\n");else printf("NO\n")
#define popcount(v) __builtin_popcountll(v)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define vector3d(type,name,h,w,...) vector<vector<vector<type>>>name(h,vector<vector<type>>(w,vector<type>(__VA_ARGS__)))
#define vector4d(type,name,h,w,d,...) vector<vector<vector<vector<type>>>>name(h,vector<vector<vector<type>>>(w,vector<vector<type>>(d,vector<type>(__VA_ARGS__))))
using namespace std;
using ll = long long;
template<class T> using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
const int MOD=1000000007;
const int MOD2=998244353;
const int INF=1<<30;
const ll INF2=1LL<<60;
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T,class L>void scan(pair<T, L>& p){scan(p.first);scan(p.second);}
template<class T,class U,class V>void scan(tuple<T,U,V>& p){scan(get<0>(p));scan(get<1>(p));scan(get<2>(p));}
template<class T, size_t size> void scan(array<T, size>& a){ for(auto&& i : a) scan(i);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T,class L>void print(const pair<T, L>& p){print(p.first);putchar(' ');print(p.second);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll modinv(ll a, ll m) {ll b = m, u = 1, v = 0;while (b) {ll t = a / b;a -= t * b; swap(a, b);u -= t * v; swap(u, v);}u %= m;if (u < 0) u += m;return u;}
ll updivide(ll a,ll b){return (a+b-1)/b;}
int msb(ll v){return 63-__builtin_clzll(v);}
template<class T> void chmax(T &a,const T b){if(b>a)a=b;}
template<class T> void chmin(T &a,const T b){if(b<a)a=b;}

int main(){
    INT(n);
    vector<int> a(n);
    in(a);
    int ans=INF,cnt=accumulate(all(a),0);
    ans=cnt;
    rep(i,n){
        if(a[i]==1)cnt--;
        else cnt++;
        chmin(ans,cnt);
    }
    out(ans);
}
accuracy: 1
time_ms: 10
memory_kb: 3956
final_rank: 3

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 4000000000000000000 //オーバーフローに注意
#define MOD 1000000007
#define EPS 0.000000001




#define SIZE 200005

int A[SIZE];
int L[SIZE],R[SIZE];

int main(){

	int N;
	scanf("%d",&N);

	for(int i = 1; i <= N; i++){

		scanf("%d",&A[i]);
	}

	int sum = 0;

	for(int i = N; i >= 1; i--){ //初期反転を使わずにやる

		if(A[i] == 1){

			sum++;
		}
		R[i] = sum;
	}

	sum = 0;
	for(int i = 1; i <= N; i++){ //1～iまで初期反転する

		if(A[i] == 0){

			sum++;
		}
		L[i] = sum;
	}

	int ans = min(R[1],L[N]);
	for(int i = 1; i <= N-1; i++){

		ans = min(ans,L[i]+R[i+1]);
	}

	printf("%d\n",ans);

	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5552
final_rank: 6