2023-08-30：用go语言编写。两个魔法卷轴问题。 给定一个数组arr，其中可能有正、负、0， 一个魔法卷轴可以把arr中连续的一段全变成0，你希望数组整体的累加和尽可能大。 你有两个魔法卷轴，

2023-08-30：用go语言编写。两个魔法卷轴问题。

给定一个数组arr，其中可能有正、负、0，

一个魔法卷轴可以把arr中连续的一段全变成0，你希望数组整体的累加和尽可能大。

你有两个魔法卷轴，请返回数组尽可能大的累加和。

1 <= arr长度 <= 100000，

-100000 <= arr里的值 <= 100000。

来自微众银行。

来自左程云。

答案2023-08-30：

算法maxSum1：

1.定义一个辅助函数max，用于返回两个数中的最大值。

2.定义函数maxSum1，接收一个整数数组arr作为参数，返回一个整数。

3.初始化变量p1为0，遍历数组arr，累加每个元素到p1。

4.获取数组arr的长度n。

5.调用函数mustOneScroll(arr, 0, n-1)，返回一个整数，并赋值给变量p2。

6.初始化变量p3为math.MinInt32。

7.循环变量i从1到n-1：

• 调用函数mustOneScroll(arr, 0, i-1)，返回一个整数，并与调用函数mustOneScroll(arr, i, n-1)的返回值相加，得到一个新的整数。

• 调用max函数，将p3与新整数比较，取较大值赋给p3。

8.调用max函数三次，分别比较p1、p2和p3的值，返回最大值作为结果。

算法maxSum2：

1.定义一个辅助函数max，用于返回两个数中的最大值。

2.定义函数maxSum2，接收一个整数数组arr作为参数，返回一个整数。

3.如果数组arr的长度为0，直接返回0。

4.初始化变量p1为0，遍历数组arr，累加每个元素到p1。

5.获取数组arr的长度n。

6.创建长度为n的数组left，用于存储每个位置左边范围内的最大累加和。

7.初始化变量sum为arr[0]，maxSum为max(0, sum)。

8.循环变量i从1到n-1：

• 将left[i]设置为max(left[i-1]+arr[i], maxSum)。

• 累加arr[i]到sum。

• 用max函数比较maxSum和sum的值，将较大值赋给maxSum。

9.创建长度为n的数组right，用于存储每个位置右边范围内的最大累加和。

10.初始化变量sum为arr[n-1]，maxSum为max(0, sum)。

11.倒序循环变量i从n-2到0：

- 将right[i]设置为max(arr[i]+right[i+1], maxSum)。

- 累加arr[i]到sum。

- 用max函数比较maxSum和sum的值，将较大值赋给maxSum。

12.初始化变量p2为left[n-1]。

13.初始化变量p3为math.MinInt32。

14.循环变量i从1到n-1：

- 将left[i-1]+right[i]的值与p3比较，取较大值赋给p3。

15.调用max函数三次，分别比较p1、p2和p3的值，返回最大值作为结果。

时间复杂度和空间复杂度：

• 对于maxSum1算法，时间复杂度为O(N^3)，其中N为数组arr的长度。空间复杂度为O(1)。

• 对于maxSum2算法，时间复杂度为O(N)，其中N为数组arr的长度。空间复杂度为O(N)（需要额外的left和right数组）。

go完整代码如下：

package main

import (
	"fmt"
	"math"
	"math/rand"
	"time"
)

// 暴力方法
// 为了测试
func maxSum1(arr []int) int {
	p1 := 0
	for _, num := range arr {
		p1 += num
	}
	n := len(arr)
	p2 := mustOneScroll(arr, 0, n-1)
	p3 := math.MinInt32
	for i := 1; i < n; i++ {
		p3 = max(p3, mustOneScroll(arr, 0, i-1)+mustOneScroll(arr, i, n-1))
	}
	return max(p1, max(p2, p3))
}

// 为了测试
func mustOneScroll(arr []int, L, R int) int {
	ans := math.MinInt32
	for a := L; a <= R; a++ {
		for b := a; b <= R; b++ {
			curAns := 0
			for i := L; i < a; i++ {
				curAns += arr[i]
			}
			for i := b + 1; i <= R; i++ {
				curAns += arr[i]
			}
			ans = max(ans, curAns)
		}
	}
	return ans
}

// 正式方法
// 时间复杂度O(N)
func maxSum2(arr []int) int {
	if len(arr) == 0 {
		return 0
	}
	// 一个卷轴也不用
	p1 := 0
	for _, num := range arr {
		p1 += num
	}
	n := len(arr)
	// left[i] : 0 ~ i范围上，一定要用一次卷轴的情况下，最大累加和多少
	left := make([]int, n)
	// left[0] = 0 : 0 ~ 0，一定要用一次卷轴的情况下，最大累加和多少
	// 每一步的前缀和
	// 0~0 前缀和
	sum := arr[0]
	// 之前所有前缀和的，最大值
	maxSum := max(0, sum)
	for i := 1; i < n; i++ {
		// left[i - 1] + arr[i]
		// maxSum : 之前所有前缀和的，最大值
		left[i] = max(left[i-1]+arr[i], maxSum)
		sum += arr[i]
		maxSum = max(maxSum, sum)
	}
	// 只用一次卷轴，必须用，0~n-1范围上的解，第二种可能性
	p2 := left[n-1]
	// 第三种 ：一定要用两次卷轴
	right := make([]int, n)
	// right[i] : i ~ n-1范围上，一定要用一次卷轴的情况下，最大累加和多少
	sum = arr[n-1]
	maxSum = max(0, sum)
	for i := n - 2; i >= 0; i-- {
		right[i] = max(arr[i]+right[i+1], maxSum)
		sum += arr[i]
		maxSum = max(maxSum, sum)
	}
	p3 := math.MinInt32
	for i := 1; i < n; i++ {
		// 0..0 1...n-1
		// 0..1 2...n-1
		// 0..2 3...n-1
		p3 = max(p3, left[i-1]+right[i])
	}
	return max(p1, max(p2, p3))
}

// 辅助函数，返回两个数中的最大值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// 为了测试
func randomArray(n, v int) []int {
	arr := make([]int, n)
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < n; i++ {
		arr[i] = rand.Intn(2*v+1) - v
	}
	return arr
}

func main() {
	rand.Seed(time.Now().UnixMilli())
	N := 50
	V := 100
	testTimes := 10000
	fmt.Println("测试开始")
	for i := 0; i < testTimes; i++ {
		n := rand.Intn(N)
		arr := randomArray(n, V)
		ans1 := maxSum1(arr)
		ans2 := maxSum2(arr)
		if ans1 != ans2 {
			fmt.Println("出错了!")
		}
	}
	fmt.Println("测试结束")
}

rust完整代码如下：

use std::cmp;

// 暴力方法
// 为了测试
fn max_sum1(arr: &[i32]) -> i32 {
    let mut p1 = 0;
    for &num in arr {
        p1 += num;
    }
    let n = arr.len() as i32;
    let mut p2 = must_one_scroll(arr, 0, n - 1);
    let mut p3 = i32::MIN;
    for i in 1..n {
        p3 = cmp::max(
            p3,
            must_one_scroll(arr, 0, i - 1) + must_one_scroll(arr, i, n - 1),
        );
    }
    cmp::max(p1, cmp::max(p2, p3))
}

// 为了测试
fn must_one_scroll(arr: &[i32], l: i32, r: i32) -> i32 {
    let mut ans = i32::MIN;
    for a in l..=r {
        for b in a..=r {
            let mut cur_ans = 0;
            for i in l..a {
                cur_ans += arr[i as usize];
            }
            for i in b + 1..=r {
                cur_ans += arr[i as usize];
            }
            ans = cmp::max(ans, cur_ans);
        }
    }
    ans
}

// 正式方法
// 时间复杂度O(N)
fn max_sum2(arr: &[i32]) -> i32 {
    if arr.is_empty() {
        return 0;
    }
    // 一个卷轴也不用
    let mut p1 = 0;
    for &num in arr {
        p1 += num;
    }
    let n = arr.len() as i32;
    // left[i] : 0 ~ i范围上，一定要用一次卷轴的情况下，最大累加和多少
    let mut left = vec![0; n as usize];
    // left[0] = 0 : 0 ~ 0，一定要用一次卷轴的情况下，最大累加和多少
    // 每一步的前缀和
    // 0~0 前缀和
    let mut sum = arr[0];
    // 之前所有前缀和的，最大值
    let mut max_sum = cmp::max(0, sum);
    for i in 1..n {
        // left[i - 1] + arr[i]
        // max_sum : 之前所有前缀和的，最大值
        left[i as usize] = cmp::max(left[i as usize - 1] + arr[i as usize], max_sum);
        sum += arr[i as usize];
        max_sum = cmp::max(max_sum, sum);
    }
    // 只用一次卷轴，必须用，0~n-1范围上的解，第二种可能性
    let p2 = left[n as usize - 1];
    // 第三种 ：一定要用两次卷轴
    let mut right = vec![0; n as usize];
    // right[i] : i ~ n-1范围上，一定要用一次卷轴的情况下，最大累加和多少
    sum = arr[n as usize - 1];
    max_sum = cmp::max(0, sum);
    for i in (0..n - 1).rev() {
        right[i as usize] = cmp::max(arr[i as usize] + right[i as usize + 1], max_sum);
        sum += arr[i as usize];
        max_sum = cmp::max(max_sum, sum);
    }
    let mut p3 = i32::MIN;
    for i in 1..n {
        // 0..0 1...n-1
        // 0..1 2...n-1
        // 0..2 3...n-1
        p3 = cmp::max(p3, left[i as usize - 1] + right[i as usize]);
    }
    cmp::max(p1, cmp::max(p2, p3))
}

// 为了测试
fn random_array(n: usize, v: i32) -> Vec<i32> {
    let mut arr = vec![0; n];
    for i in 0..n {
        arr[i] = (rand::random::<i32>() % (v * 2 + 1)) - v;
    }
    arr
}

// 为了测试
fn main() {
    let n = 50;
    let v = 100;
    let test_times = 10_000;
    println!("测试开始");
    for _ in 0..test_times {
        let n = rand::random::<usize>() % n;
        let arr = random_array(n, v);
        let ans1 = max_sum1(&arr);
        let ans2 = max_sum2(&arr);
        if ans1 != ans2 {
            println!("出错了!");
        }
    }
    println!("测试结束");
}

c++完整代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

int mustOneScroll(vector<int>& arr, int L, int R) {
    int ans = INT_MIN;
    for (int a = L; a <= R; a++) {
        for (int b = a; b <= R; b++) {
            int curAns = 0;
            for (int i = L; i < a; i++) {
                curAns += arr[i];
            }
            for (int i = b + 1; i <= R; i++) {
                curAns += arr[i];
            }
            ans = max(ans, curAns);
        }
    }
    return ans;
}

int maxSum1(vector<int>& arr) {
    int p1 = 0;
    for (int num : arr) {
        p1 += num;
    }
    int n = arr.size();
    int p2 = mustOneScroll(arr, 0, n - 1);
    int p3 = INT_MIN;
    for (int i = 1; i < n; i++) {
        p3 = max(p3, mustOneScroll(arr, 0, i - 1) + mustOneScroll(arr, i, n - 1));
    }
    return max(p1, max(p2, p3));
}

int maxSum2(vector<int>& arr) {
    if (arr.size() == 0) {
        return 0;
    }
    int p1 = 0;
    for (int num : arr) {
        p1 += num;
    }
    int n = arr.size();
    vector<int> left(n);
    int sum = arr[0];
    int maxSum = max(0, sum);
    for (int i = 1; i < n; i++) {
        left[i] = max(left[i - 1] + arr[i], maxSum);
        sum += arr[i];
        maxSum = max(maxSum, sum);
    }
    int p2 = left[n - 1];
    vector<int> right(n);
    sum = arr[n - 1];
    maxSum = max(0, sum);
    for (int i = n - 2; i >= 0; i--) {
        right[i] = max(arr[i] + right[i + 1], maxSum);
        sum += arr[i];
        maxSum = max(maxSum, sum);
    }
    int p3 = INT_MIN;
    for (int i = 1; i < n; i++) {
        p3 = max(p3, left[i - 1] + right[i]);
    }
    return max(p1, max(p2, p3));
}

vector<int> randomArray(int n, int v) {
    vector<int> arr(n);
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % (2 * v + 1) - v;
    }
    return arr;
}

int main() {
    int N = 50;
    int V = 100;
    int testTimes = 10000;
    cout << "测试开始" << endl;
    for (int i = 0; i < testTimes; i++) {
        int n = rand() % N;
        vector<int> arr = randomArray(n, V);
        int ans1 = maxSum1(arr);
        int ans2 = maxSum2(arr);
        if (ans1 != ans2) {
            cout << "出错了!" << endl;
        }
    }
    cout << "测试结束" << endl;
    return 0;
}

c完整代码如下：

#include <stdio.h>
#include <stdlib.h>

int maxSum1(int* arr, int n);
int mustOneScroll(int* arr, int L, int R);
int maxSum2(int* arr, int n);
int* randomArray(int n, int v);

int maxSum1(int* arr, int n) {
    int p1 = 0;
    int* ptr = arr;
    for (int i = 0; i < n; i++) {
        p1 += *ptr++;
    }
    int p2 = mustOneScroll(arr, 0, n - 1);
    int p3 = -INT_MAX;
    for (int i = 1; i < n; i++) {
        p3 = (p3 > mustOneScroll(arr, 0, i - 1) + mustOneScroll(arr, i, n - 1)) ? p3 : mustOneScroll(arr, 0, i - 1) + mustOneScroll(arr, i, n - 1);
    }
    return (p1 > (p2 > p3 ? p2 : p3)) ? p1 : ((p2 > p3) ? p2 : p3);
}

int mustOneScroll(int* arr, int L, int R) {
    int ans = -INT_MAX;
    for (int a = L; a <= R; a++) {
        for (int b = a; b <= R; b++) {
            int curAns = 0;
            for (int i = L; i < a; i++) {
                curAns += *(arr + i);
            }
            for (int i = b + 1; i <= R; i++) {
                curAns += *(arr + i);
            }
            ans = (ans > curAns) ? ans : curAns;
        }
    }
    return ans;
}

int maxSum2(int* arr, int n) {
    if (n == 0) {
        return 0;
    }
    int p1 = 0;
    int* ptr = arr;
    for (int i = 0; i < n; i++) {
        p1 += *ptr++;
    }
    int* left = (int*)malloc(n * sizeof(int));
    int* right = (int*)malloc(n * sizeof(int));
    int sum, maxSum;

    sum = *arr;
    maxSum = (0 > sum) ? 0 : sum;
    *left = (0 > (*arr)) ? 0 : (*arr);
    for (int i = 1; i < n; i++) {
        *(left + i) = (*(left + i - 1) + *(arr + i) > maxSum) ? *(left + i - 1) + *(arr + i) : maxSum;
        sum += *(arr + i);
        maxSum = (maxSum > sum) ? maxSum : sum;
    }

    int p2 = *(left + (n - 1));

    sum = *(arr + (n - 1));
    maxSum = (0 > sum) ? 0 : sum;
    *(right + (n - 1)) = (0 > (*(arr + (n - 1)))) ? 0 : (*(arr + (n - 1)));
    for (int i = n - 2; i >= 0; i--) {
        *(right + i) = (*(arr + i) + *(right + i + 1) > maxSum) ? (*(arr + i) + *(right + i + 1)) : maxSum;
        sum += *(arr + i);
        maxSum = (maxSum > sum) ? maxSum : sum;
    }

    int p3 = -INT_MAX;
    for (int i = 1; i < n; i++) {
        p3 = (p3 > (*(left + i - 1) + *(right + i))) ? p3 : (*(left + i - 1) + *(right + i));
    }

    int result = (p1 > (p2 > p3 ? p2 : p3)) ? p1 : ((p2 > p3) ? p2 : p3);

    free(left);
    free(right);

    return result;
}

int* randomArray(int n, int v) {
    int* arr = (int*)malloc(n * sizeof(int));
    int* ptr = arr;
    for (int i = 0; i < n; i++) {
        *ptr++ = (rand() % (2 * v + 1)) - v;
    }
    return arr;
}

int main() {
    int N = 50;
    int V = 100;
    int testTimes = 10000;
    printf("测试开始\n");
    for (int i = 0; i < testTimes; i++) {
        int n = rand() % N;
        int* arr = randomArray(n, V);
        int ans1 = maxSum1(arr, n);
        int ans2 = maxSum2(arr, n);
        if (ans1 != ans2) {
            printf("出错了!\n");
        }
        free(arr);
    }
    printf("测试结束\n");
    return 0;
}