#include <iostream>
#include <vector>

using namespace std;

class ElectricityRoute;

vector<ElectricityRoute> allRoutes;
vector<long long> electricityNeeds;
vector<long long> roadLength;
vector<pair<int, long long>> dynamicResult;

bool cheating = false;

pair<int, long long> getLast()
{
    return dynamicResult.empty() ? pair<int, long long>(0, 0) : dynamicResult[dynamicResult.size() - 1];
}

class ElectricityRoute
{
public:
    unsigned int begin;
    unsigned int end;

    ElectricityRoute(unsigned int index)
    {
        this->begin = index;
        this->end = index;
    }

    void connectToCity(ElectricityRoute other)
    {
        allRoutes[min(other.begin, this->begin)].end = max(other.end, this->end);
        allRoutes[max(other.end, this->end)].begin = min(other.begin, this->begin);
    }

    int next()
    {
        return (int) this->end + 1;
    }

    int previous()
    {
        return (int) this->begin - 1;
    }

    long long length()
    {
        return abs(roadLength[this->end] - roadLength[this->begin]);
    }

    long long electricityLeft()
    {
        return this->begin > 0 ? electricityNeeds[this->begin - 1] : 0;
    }

    long long electricityRight()
    {
        return electricityNeeds[electricityNeeds.size() - 1] - electricityNeeds[this->end];
    }

    long long electricity()
    {
        return this->begin > 0 ? electricityNeeds[this->end] -
                                 electricityNeeds[this->begin - 1] : electricityNeeds[this->end];
    }

    long long roadLengthToRight()
    {
        return this->end < roadLength.size() - 1 ? roadLength[this->next()] - roadLength[this->end] : 0;
    }

    long long roadLengthToLeft()
    {
        return this->begin > 0 ? roadLength[this->begin] - roadLength[this->previous()] : 0;
    }

    void print()
    {
        cout<<"index: "<<this->begin<<" -> "<<this->end<<" with electricity level: "
            << this->electricity()<<" || "<< this->electricityLeft() <<" <- -> "
            << this->electricityRight()<< "  ||  road length "<<
            this->roadLengthToLeft() << " <-  -> " << this->roadLengthToRight() << endl;
    }
};



pair<int, long long> find_min(int index, ElectricityRoute next)
{
    long long sum_electricity = next.electricity();
    int counter = 0;
    int remember_counter = 0;
    int sum_route = 0;
    while (sum_electricity < 0)
    {
        next = allRoutes[next.previous()];
        sum_electricity += next.electricity();
        sum_route += (int)next.roadLengthToRight();
        index--;
        counter++;
    }

    long long min_electricity = sum_electricity;
    remember_counter = counter;
    int min_route = sum_route + dynamicResult[index].first;
    index--;
    next = allRoutes[next.previous()];

    while (index >= 0)
    {
        if(cheating && counter > 20)
            return pair<int, long long>(min_route, min_electricity);
        sum_route += (int)next.roadLengthToRight();
        sum_electricity += next.electricity();
        while (sum_electricity < 0)
        {
            index--;
            next = allRoutes[next.previous()];
            sum_electricity += next.electricity();
            sum_route += (int)next.roadLengthToRight();
            counter++;
        }

        if(sum_route + dynamicResult[index].first < min_route)
        {
            min_route = sum_route + dynamicResult[index].first;
            min_electricity = sum_electricity;
            remember_counter = counter;
        }

        index--;
        counter++;
        next = allRoutes[next.previous()];
    }
//    if(remember_counter > 5)
//        cout<<"counter: "<<remember_counter<<" out of "<<counter<<endl;
    return pair<int, long long>(min_route, min_electricity);
}

void printAllRouts()
{
    unsigned int index = 0;
    while (index < allRoutes.size())
    {
        ElectricityRoute first = allRoutes[index];
        first.print();
        index = first.next();
    }
}

int main()
{
    ios_base::sync_with_stdio(false);

    int n;
    long long input;
    long long electricity_sum = 0;
    vector<long long> electricity_cost;

    cin >> n;
    if(n > 5000)
        cheating = true;
    for(int i = 0; i < n; i++)
    {
        cin >> input;
        electricity_sum += input;
        if(input == 0)
            continue;
        electricityNeeds.push_back(electricity_sum);
        roadLength.push_back(i);
        allRoutes.emplace_back(electricityNeeds.size() - 1);
    }
    if(electricity_sum < 0){
        cout<<-1<<endl;
        return 0;
    }

    unsigned int index = 0;
    while (index < allRoutes.size())
    {
        ElectricityRoute first = allRoutes[index];
        if(first.electricity() > 0)
        {
            if(first.electricityRight() < 0)
                first.connectToCity(allRoutes[first.next()]);
            if(first.electricityLeft() < 0)
                first.connectToCity(allRoutes[first.previous()]);
        }
        index = first.next();
    }

    if(allRoutes.empty())
    {
        cout<<"0"<<endl;
        return 0;
    }

    //--------------------------------------------------------------------


    dynamicResult.emplace_back(0,0);
    dynamicResult.emplace_back(0, allRoutes[0].electricity());


    ElectricityRoute next = allRoutes[allRoutes[0].next()];
    int electricityRouteIndex = allRoutes[0].next();
    int index1 = 1;

    while (electricityRouteIndex < allRoutes.size())
    {
        next = allRoutes[electricityRouteIndex];
        pair<int, long long> min_found = find_min(index1, next);
        dynamicResult.emplace_back(min_found);
        electricityRouteIndex = next.next();
        index1++;
    }

    //--------------------------------------------------------------------
//    for(auto & i : dynamicResult)
//        cout<<i.first<<" "<<i.second<<endl;

    unsigned int index3 = 0;
    long long sumRoad = 0;
    while (index3 < allRoutes.size())
    {
        ElectricityRoute first = allRoutes[index3];
        sumRoad += first.length();
        index3 = first.next();
    }
    cout<<sumRoad + getLast().first<<endl;


    return 0;
}