for(int i=2;i<=n;i++)
if(a[i-1]+a[i]<0){
ans++;
a[i]=10^18;
}
This should work

sorry for my poor English

$$$10^5\times10^9<10^{18}$$$ so that means, we can separate the array to some segments by the position we choose to change. and for each subarrays of these segments, the sum must be positive.

we can search from the head of the array. it is obviously that the number we choose to change is better to be more backword. so we can use dp to maintain the segment.

Fact 1. It's always optimal to replace by $$$10^{18}$$$. Moreover, if you replace by this number, all arrays that contain this element will have $$$sum > 0$$$.

Fact 2. It's sufficient to check this condition on all subarrays of length 2 or 3. Proof. It can be shown that every integer $$$n > 1$$$ is representable as $$$n = 2x + 3y$$$ where $$$x, y \geq 0$$$ and $$$x$$$, $$$y$$$ are integers. So you can partition each subarray into subarrays of length 2 and 3 and if they have positive sum then the whole subarray will have positive sum.

Now you can use simple DP. Let $$$dp_{i, j}$$$ be the minimum number of replacements if we visited first $$$i$$$ elements and the last $$$10^{18}$$$ is on position $$$i - j$$$. This DP obviously have $$$O(n^2)$$$ states. So instead of keeping the actual position, let's keep $$$3$$$ instead if last $$$10^{18}$$$ is far away (position of it is less than $$$i - 2$$$). Transitions:

1) Replace next element by $$$10^{18}$$$. Then you should do $$$dp_{i + 1, 0} := min(dp_{i + 1, 0}, min(dp_{i, 0}, dp_{i, 1}, dp_{i, 2}, dp_{i, 3}))$$$.

2) Don't replace next element by anything. Then you should check if the condition on sum will be still satisfied and relax the DP.

Can you think of any case which fails this ??

//Min number of operations to make array such that all subarrays of len>1 have sum >=0

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

//-10^9 <= arr[i] <= 10^9
// 1<len(arr)<=10^5

//10^18
long long m = 100000000000000000;

int minOperations(vector<int> &arr)
{
    int n=arr.size();

    //Has no subarray of len>1
    if(n == 1) return 0;

    //Has only one subarray of len>1
    if(n == 2) return arr[0]+arr[1]<0;

    int cnt = 0;

    long long prev,curr,next;

    prev = m;
    curr = arr[0];
    next = arr[1];

    int ind = 1;

    //cout<<ind<<" "<<cnt<<endl;
    while(ind<n)
    {   
        if(prev+curr+next<0 || curr+next<0)
        {
            //set next as max, and in next iteration curr=next so 
            prev = curr;
            curr = m;
            cnt++;
        }else{
            prev = curr;
            curr = next;
        }

        //cout<<ind<<" "<<cnt<<endl;
        if(ind<n) next = arr[ind+1];
        ind++;
    }

    return cnt;
}

int main()
{
    //vector<int> arr = {2,5,-8,-1,2};
    //vector<int> arr = {-1,-1,-1,-1,-1};
    // vector<int>arr = {6,-5,5,10,-1,12};
    //vector<int>arr = {-2,3,-2};
    vector<int>arr = {-80,100,-120,140};
    cout<<minOperations(arr)<<endl;

}