#include<bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1e18;
int n;
int a[500005];
int dp[500005];
int ult[500005];
int pref[500005];
struct node
{
int dpval=-1;
int ultval=-1;
int tole=-1;
int tori=-1;
};
node mymax(node x, node y)
{
node rez;
if(x.dpval>y.dpval)
return x;
if(x.dpval<y.dpval)
return y;
if(x.ultval>y.ultval)
return x;
return y;
}
node emp;
vector<node> aint;
void upd(int nod, int st, int dr, int poz, node newv)
{
if(st==dr)
{
aint[nod]=mymax(aint[nod],newv);
return;
}
if(aint[nod].tole==-1)
{
aint[nod].tole=aint.size();
aint.push_back(emp);
}
if(aint[nod].tori==-1)
{
aint[nod].tori=aint.size();
aint.push_back(emp);
}
int mij=(st+dr)/2;
if(poz<=mij) upd(aint[nod].tole,st,mij,poz,newv);
else upd(aint[nod].tori,mij+1,dr,poz,newv);
node aux = mymax(aint[aint[nod].tole], aint[aint[nod].tori]);
aint[nod].dpval = aux.dpval;
aint[nod].ultval = aux.ultval;
}
node qry(int nod, int st, int dr, int le, int ri)
{
if(le>ri)
return emp;
if(le==st && dr==ri)
return aint[nod];
if(aint[nod].tole==-1)
{
aint[nod].tole=aint.size();
aint.push_back(emp);
}
if(aint[nod].tori==-1)
{
aint[nod].tori=aint.size();
aint.push_back(emp);
}
int mij=(st+dr)/2;
return mymax(qry(aint[nod].tole,st,mij,le,min(mij,ri)),
qry(aint[nod].tori,mij+1,dr,max(mij+1,le),ri));
}
signed main()
{
emp={-1,-1,-1,-1};
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
pref[i]=pref[i-1]+a[i];
}
dp[0]=0;
ult[0]=0;
aint.push_back(emp);
upd(0,0,INF,0,{0,0,-1,-1});
for(int i=1;i<=n;i++)
{
dp[i]=-1;
/**for(int x=i-1;x>=0;x--)
{
if(dp[x]+1<dp[i-1])
break;
if(ult[x]+pref[x]<=pref[i])
{
dp[i]=dp[x]+1;
ult[i]=pref[i]-pref[x];
break;
}
}*/
node aux = qry(0,0,INF,0,pref[i]);
dp[i]=aux.dpval+1;
ult[i]=pref[i]-pref[aux.ultval];
if(dp[i-1]>dp[i] || (dp[i-1]==dp[i] && ult[i-1]+a[i]<ult[i]))
{
dp[i]=dp[i-1];
ult[i]=ult[i-1]+a[i];
}
upd(0,0,INF,ult[i]+pref[i],{dp[i],i,-1,-1});
}
cout<<dp[n];
return 0;
}
/**
dp[i] = numarul maxime de secvente in care pot fi impartite primele i elemente
ult[i] = suma ultimei secvente din solutia pt dp[i]
dp[i] max= dp[i-1]
dp[i] max= max(dp[x]+1) pt x = 0..i-1 && ult[x] + pref[x] <= pref[i]
*/
