Optimize the following C++ code for time and memor...

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

long long sumValidTelemetry(int n, vector<long long> readings) {
    long long sum = 0;

    for (long long value : readings) {
        if (value != -1) {
            sum += value;
        }
    }

    return sum;
}

This is the best fit for the function signature shown in your screenshot. Each telemetry reading is checked once; corrupted packets (-1) are skipped and all valid readings are added.

For the sample:

text
5
10 -1 20 -1 5

the result is 35.

Time Complexity: O(n)
Auxiliary Space: O(1)

You can paste this directly into the sumValidTelemetry function on the coding platform.

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

long long countBalancedSegments(
    int n, int K, int M,
    vector<int> x,
    vector<int> p
) {
    // x[i] is in [1, n] according to the constraints.
    vector<int> channelFreq(n + 1, 0);

    // prefixMod[i] = (p[0] + ... + p[i-1]) % M
    vector<int> prefixMod(n + 1, 0);

    // Number of currently valid prefix positions having each remainder.
    vector<int> remainderFreq(M, 0);

    long long answer = 0;
    int left = 0;

    // prefix position 0 is initially a possible starting point.
    remainderFreq[0] = 1;

    for (int right = 0; right < n; ++right) {
        ++channelFreq[x[right]];

        // Maintain the smallest valid left boundary such that
        // no channel occurs more than K times.
        while (channelFreq[x[right]] > K) {
            --channelFreq[x[left]];

            // prefixMod[left] can no longer be used as a start.
            --remainderFreq[prefixMod[left]];

            ++left;
        }

        prefixMod[right + 1] =
            (prefixMod[right] + static_cast<long long>(p[right])) % M;

        // Sum(left..right) is divisible by M iff:
        // prefixMod[left] == prefixMod[right + 1].
        answer += remainderFreq[prefixMod[right + 1]];

        // This prefix can be a starting position for future segments.
        ++remainderFreq[prefixMod[right + 1]];
    }

    return answer;
}

Why this is optimal

The problem asks for the number of contiguous stretches satisfying both:

1. No channel occurs more than K times.
2. The sum of power values is divisible by M.

The code combines two techniques:

• A sliding window keeps the channel-frequency condition valid.
• Prefix sum modulo M counts valid power sums in O(1) per tower.

For a stretch [l, r]:

text
sum(l..r) % M == 0

exactly when:

text
prefix[l] % M == prefix[r+1] % M

So remainderFreq tells us immediately how many valid starting positions exist for every right.

For the sample shown in the screenshot, it returns:

text
4

Complexity

Time: O(n) — each tower enters and leaves the sliding window at most once.

Space: O(n + M).

With n <= 100000, this is efficient enough for the hidden test cases and avoids the O(n²) approach of checking every possible contiguous stretch.

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

long long countBalancedSegments(
    int n,
    int K,
    int M,
    vector<long long> x,
    vector<long long> p
) {
    vector<int> channelCount(n + 1, 0);
    vector<int> prefixMod(n + 1, 0);
    vector<int> modCount(M, 0);

    long long ans = 0;
    int left = 0;

    // Empty prefix before index 0.
    modCount[0] = 1;

    for (int right = 0; right < n; ++right) {

        // Add current channel to the sliding window.
        ++channelCount[x[right]];

        // Make the window valid:
        // every channel must occur at most K times.
        while (channelCount[x[right]] > K) {
            --channelCount[x[left]];

            // Prefix corresponding to this start index
            // is no longer allowed.
            --modCount[prefixMod[left]];

            ++left;
        }

        // Prefix sum modulo M.
        long long val = p[right] % M;
        if (val < 0) val += M;

        prefixMod[right + 1] =
            (prefixMod[right] + val) % M;

        // prefix[r+1] == prefix[l] (mod M)
        // => sum(l..r) divisible by M.
        ans += modCount[prefixMod[right + 1]];

        // Current prefix may be used for future segments.
        ++modCount[prefixMod[right + 1]];
    }

    return ans;
}

Why this is the best approach

A segment is valid when both conditions hold:

1. Every channel appears at most K times.
2. Sum of powers is divisible by M.

For the first condition, we maintain a sliding window [left, right]. When a channel frequency becomes greater than K, we move left forward until the window becomes valid again.

For the second condition, use prefix sums modulo M.

If:

text
prefix[r + 1] % M == prefix[l] % M

then:

text
sum(l ... r) % M == 0

modCount stores how many currently allowed starting prefixes have each remainder, so every segment is counted in constant time.

The crucial part is that when left moves, we also remove:

cpp
--modCount[prefixMod[left]];

so invalid segment starting positions can never be counted.

Complexity

• Time: O(n)
• Space: O(n + M)

Each tower enters the window once and leaves it at most once, so this is optimal asymptotically.

For the sample shown in your screenshot, this produces:

text
4

Also, use the exact signature above if your editor shows:

cpp
vector<long long> x, vector<long long> p

which is what your latest function screenshot appears to use.

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

int calculateMaxSatisfaction(int N, vector<int> satisfaction) {
    sort(satisfaction.begin(), satisfaction.end());

    int suffixSum = 0;
    int answer = 0;

    // Add dishes from highest satisfaction to lowest.
    for (int i = N - 1; i >= 0; --i) {
        suffixSum += satisfaction[i];

        // Adding any further smaller value can only make
        // the suffix sum worse, so we can stop.
        if (suffixSum <= 0)
            break;

        answer += suffixSum;
    }

    return answer;
}

Explanation

The optimal selected dishes should always be served in increasing satisfaction order.

After sorting, process dishes from the largest satisfaction backward. Suppose the currently selected dishes have total satisfaction suffixSum. Adding a new dish before all of them increases the total score by exactly the new suffixSum.

So we keep adding a dish only while:

cpp
suffixSum > 0

Once it becomes <= 0, adding that dish—or any smaller dish after it—cannot improve the answer, so we stop immediately.

For the screenshot sample:

text
satisfaction = [-1, -8, 0, 5, -9]

Optimal dishes:

text
[-1, 0, 5]

Score:

text
1*(-1) + 2*0 + 3*5 = 14

Complexity

• Time: O(N log N) due to sorting
• Extra Space: O(1) apart from the input vector/sort implementation
• Traversal: O(N)

This greedy solution is substantially better than the O(N²) DP approach and handles all-negative, all-positive, zero, and mixed cases correctly.