Are you familiar with the standard Kadane's max subarray sum?

Then how can you apply that kind of idea to this problem?

The problem requires you to take a :

1) Consecutive non-empty subarray.

2) Or a subarray that has an element missed in the middle of it.

For the first case, see Kadane's Algorithm explanation here :

https://www.geeksforgeeks.org/dsa/largest-sum-contiguous-subarray/

Now let's see the second case where we should find a consecutive subarray from L to R.. but there is an index i such that L < i < R missed, let's iterate over all possible 'i' that may be missed .. then we have to find some L and R such that the sum of two segments (L->i-1), (i+1->R) is maximized.. this can be done using prefix sums.

I've implemented the solution and got accepted :

void nl()
{
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++)
        cin >> a[i];
    int ans = *max_element(all(a)); // initial value for the answer (taking a segment with length 1) you can initialize it with -inf also.

    vector<int> pre(n + 1), suf(n + 2);
    for (int i = 0; i < n; i++)
        pre[i + 1] = pre[i] + a[i];
    for (int i = n - 1; i >= 0; i--)
        suf[i + 1] = suf[i + 2] + a[i];
    vector<int> premn(n + 1), sufmn(n + 2);
    for (int i = 0; i < n; i++)
        premn[i + 1] = min(premn[i], pre[i + 1]);
    for (int i = n - 1; i >= 0; i--)
        sufmn[i + 1] = min(sufmn[i + 2], suf[i + 1]);
    for (int i = 0; i < n; i++)
    {
        ans = max(ans, pre[i + 1] - premn[i]); // this is the same as Kadane's Algorithm
        if (i + 1 < n){ // ensuring that we take at least one element from the right side (to ensure that the segment is non-empty)
            ans = max(ans, pre[i] - premn[i] + suf[i + 2] - sufmn[i + 3]);
        }
        if (i > 0){ // ensuring that we take at least one element from the left side (to ensure that the segment is non-empty)
            ans = max(ans, pre[i] - premn[i - 1] + suf[i + 2] - sufmn[i + 2]);
        }
    }
    cout << ans << '\n';
}