删除操作后的最大子段和

/*
 * Solution using Java Stream API
 * 
 * Idea: Similar to the above solution but using Java Streams for the operations
 * like calculating prefix sums and finding maximums. Since Streams are not optimal
 * for this type of problem, this implementation is just for demonstration.
 */

import java.util.*;
import java.util.stream.IntStream;

public class StreamSolution {
    public int[] maximumSegmentSum(int[] nums, int[] removeQueries) {
        int n = nums.length;
        int[] answer = new int[n];
        long[] prefixSum = new long[n + 1];
        IntStream.range(0, n).forEach(i -> prefixSum[i + 1] = prefixSum[i] + nums[i]);
        Set<Integer> removed = new HashSet<>();
        long maxSum = Arrays.stream(nums).sum();
        for (int i = 0; i < n; i++) {
            int removeIndex = removeQueries[i];
            removed.add(removeIndex);
            maxSum = Long.MIN_VALUE;
            int start = 0;
            while (start < n) {
                while (start < n && removed.contains(start)) start++;
                int end = start;
                while (end < n && !removed.contains(end)) end++;
                long sum = IntStream.range(start, end).mapToLong(j -> nums[j]).sum();
                maxSum = Math.max(maxSum, sum);
                start = end;
            }
            answer[i] = (int) maxSum;
        }
        return answer;
    }
}