feat: add solutions to lc problem: No.3410 #4699

Original file line number	Diff line number	Diff line change
Expand Up		@@ -81,16 +81,26 @@ tags:

		## 解法

	<!-- solution:start -->

	### 方法一

		<!-- tabs:start -->

		#### Python3

		```python

	class Solution:
	def maxSubarraySum(self, nums: List[int]) -> int:
	max_sum = nums[0]
	min_sum = curr_sum = acc_min = 0
	dp = defaultdict(int)
	for num in nums:
	curr_sum += num
	curr = curr_sum - acc_min
	if max_sum < curr: max_sum = curr
	if num >= 0: continue
	if dp[num] > min_sum: dp[num] = min_sum
	dp[num] += num
	if acc_min > dp[num]: acc_min = dp[num]
	if min_sum > curr_sum: min_sum = curr_sum
	return max_sum
		```

		#### Java
Expand All		@@ -102,13 +112,187 @@ tags:
		#### C++

		```cpp

	struct T {
	long sum;
	long maxSubarraySumPrefix;
	long maxSubarraySumSuffix;
	long maxSubarraySum;
	T() = default;
	T(int num)
	: sum(num),
	maxSubarraySumPrefix(num),
	maxSubarraySumSuffix(num),
	maxSubarraySum(num) {}
	T(long sum, long prefix, long suffix, long maxSum)
	: sum(sum),
	maxSubarraySumPrefix(prefix),
	maxSubarraySumSuffix(suffix),
	maxSubarraySum(maxSum) {}
	};

	class SegmentTree {
	public:
	SegmentTree(const vector<int>& nums) : n(nums.size()), tree(nums.size() * 4) {
	build(nums, 0, 0, n - 1);
	}

	// Updates nums[i] to val.
	void update(int i, int val) {
	update(0, 0, n - 1, i, val);
	}

	long getMaxSubarraySum() const {
	return tree[0].maxSubarraySum;
	}

	private:
	const int n; // the size of the input array
	vector<T> tree; // the segment tree

	void build(const vector<int>& nums, int treeIndex, int lo, int hi) {
	if (lo == hi) {
	tree[treeIndex] = T(nums[lo]);
	return;
	}
	const int mid = (lo + hi) / 2;
	build(nums, 2 * treeIndex + 1, lo, mid);
	build(nums, 2 * treeIndex + 2, mid + 1, hi);
	tree[treeIndex] = merge(tree[2 * treeIndex + 1], tree[2 * treeIndex + 2]);
	}

	void update(int treeIndex, int lo, int hi, int i, int val) {
	if (lo == hi) {
	tree[treeIndex] = T(val);
	return;
	}
	const int mid = (lo + hi) / 2;
	if (i <= mid)
	update(2 * treeIndex + 1, lo, mid, i, val);
	else
	update(2 * treeIndex + 2, mid + 1, hi, i, val);
	tree[treeIndex] = merge(tree[2 * treeIndex + 1], tree[2 * treeIndex + 2]);
	}

	T merge(const T& left, const T& right) const {
	return T(
	left.sum + right.sum,
	max(left.maxSubarraySumPrefix, left.sum + right.maxSubarraySumPrefix),
	max(right.maxSubarraySumSuffix, right.sum + left.maxSubarraySumSuffix),
	max({left.maxSubarraySum, right.maxSubarraySum,
	left.maxSubarraySumSuffix + right.maxSubarraySumPrefix}));
	}
	};

	class Solution {
	public:
	long long maxSubarraySum(vector<int>& nums) {
	const bool allPositives =
	ranges::all_of(nums, [](int num) { return num >= 0; });
	const long sum = accumulate(nums.begin(), nums.end(), 0L);
	if (allPositives)
	return sum;
	const int maxNum = ranges::max(nums);
	if (maxNum < 0)
	return maxNum;

	long ans = LONG_MIN;
	unordered_map<int, vector<int>> numToIndices;
	SegmentTree tree(nums);

	for (int i = 0; i < nums.size(); ++i)
	numToIndices[nums[i]].push_back(i);

	for (const auto& [num, indices] : numToIndices) {
	for (const int index : indices)
	tree.update(index, 0);
	ans = max(ans, tree.getMaxSubarraySum());
	for (const int index : indices)
	tree.update(index, num);
	}

	return ans;
	}
	};
		```

		#### Go

		```go
	func maxSubarraySum(nums []int) int64 {
	ans := int64(nums[0])
	prefix := int64(0)
	minPrefix := int64(0)

	modifiedMinPrefix := int64(0)
	count := make(map[int]int64)
	minPrefixPlusRemoval := make(map[int]int64)

	for _, num := range nums {
	n64 := int64(num)
	prefix += n64
	if prefix-modifiedMinPrefix > ans {
	ans = prefix - modifiedMinPrefix
	}
	if n64 < 0 {
	count[num]++
	prev := minPrefixPlusRemoval[num] // по умолчанию 0
	minPrefixPlusRemoval[num] = min(prev, minPrefix) + n64
	modifiedMinPrefix = min(modifiedMinPrefix, count[num]*n64)
	modifiedMinPrefix = min(modifiedMinPrefix, minPrefixPlusRemoval[num])
	}
	minPrefix = min(minPrefix, prefix)
	modifiedMinPrefix = min(modifiedMinPrefix, minPrefix)
	}

	return ans
	}

	func min(a, b int64) int64 {
	if a < b {
	return a
	}
	return b
	}
	```

	#### Rust

	```rust
	use std::collections::HashMap;

	impl Solution {
	pub fn max_subarray_sum(nums: Vec<i32>) -> i64 {
	let mut ans: i64 = *nums.iter().max().unwrap() as i64;
	let mut prefix: i64 = 0;
	let mut min_prefix: i64 = 0;

	let mut modified_min_prefix: i64 = 0;
	let mut count: HashMap<i32, i64> = HashMap::new();
	let mut min_prefix_plus_removal: HashMap<i32, i64> = HashMap::new();

	for &num in nums.iter() {
	let n64 = num as i64;
	prefix += n64;
	ans = ans.max(prefix - modified_min_prefix);

	if n64 < 0 {
	let entry = count.entry(num).or_insert(0);
	*entry += 1;

	let prev = *min_prefix_plus_removal.get(&num).unwrap_or(&0);
	min_prefix_plus_removal.insert(num, prev.min(min_prefix) + n64);

	modified_min_prefix = modified_min_prefix.min(entry n64);
	modified_min_prefix = modified_min_prefix.min(*min_prefix_plus_removal.get(&num).unwrap());
	}

	min_prefix = min_prefix.min(prefix);
	modified_min_prefix = modified_min_prefix.min(min_prefix);
	}

	ans
	}
	}
		```

		<!-- tabs:end -->
Expand Down

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

feat: add solutions to lc problem: No.3410 #4699

Uh oh!

feat: add solutions to lc problem: No.3410 #4699

Filter by extension

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!