题目描述

给你一个正整数数组 arr ，请你计算所有可能的奇数长度子数组的和。

子数组 定义为原数组中的一个连续子序列。

请你返回 arr 中 所有奇数长度子数组的和 。

示例 1：

输入：arr = [1,4,2,5,3]
输出：58
解释：所有奇数长度子数组和它们的和为：
[1] = 1
[4] = 4
[2] = 2
[5] = 5
[3] = 3
[1,4,2] = 7
[4,2,5] = 11
[2,5,3] = 10 [
1,4,2,5,3] = 15
我们将所有值求和得到 1 + 4 + 2 + 5 + 3 + 7 + 11 + 10 + 15 = 58

示例 2：

输入：arr = [1,2]
输出：3
解释：总共只有 2 个长度为奇数的子数组，[1] 和 [2]。它们的和为 3 。

示例 3：

输入：arr = [10,11,12]
输出：66

进阶：

你可以设计一个 O(n) 时间复杂度的算法解决此问题吗？

提示：

1 <= arr.length <= 100
1 <= arr[i] <= 1000

题目链接

题目难度——简单

方法一：暴力

  根据提示，数据量很小，所以最简单的方法就是暴力，直接模拟这个过程。用一个三层循环。时间复杂度是O(N³)

代码/C++

class Solution {
public:
    int sumOddLengthSubarrays(vector<int>& arr) {
        // 暴力
        int step, i, j, res = 0, n = arr.size();
        for(i = 0; i < n; i++){
            for(step = 1; i + step <= n; step += 2){
                int right = i + step - 1;
                for(j = i; j <= right; j++){
                    res += arr[j];
                }
            }
        }
        return res;
    }
};

代码/Python

class Solution:
    def sumOddLengthSubarrays(self, arr: List[int]) -> int:
        res = 0
        n = len(arr)
        for i in range(len(arr)):
            step = 1
            while step + i <= n:
                right = step + i - 1
                for j in range(i, right + 1):
                    res += arr[j]
                step += 2
        
        return res

方法二：前缀和

  在暴力方法里，后面的奇数长度数组求和会重复加前面奇数长度加过的数，就有很多加法的浪费。所以我们可以先用一个数组，将原数组的前缀和存储起来，对每个奇数长度的子数组，用右边界的前缀和减去左边界的前缀和就是当前子数组的和。这样能将复杂度降到O(N²)。

代码/C++

class Solution {
public:
    int sumOddLengthSubarrays(vector<int>& arr) {
        // 前缀和
        int n = arr.size(), i, left, right, step, res = 0;
        vector<int> prefixSums(n + 1);
        for(i = 0; i < n; i++){
            prefixSums[i + 1] = prefixSums[i] + arr[i];
        }
        for(left = 0; left < n; left++){
            for(step = 1; step + left <= n; step += 2){
                right = left +step - 1;
                res += prefixSums[right + 1] - prefixSums[left];
            }
        }
        return res;
    }
};

代码/Python

class Solution:
    def sumOddLengthSubarrays(self, arr: List[int]) -> int:
        # 前缀和方法
        res = 0
        n = len(arr)
        prefixSum = [0] * (n + 1)
        for i in range(n):
            prefixSum[i + 1] = prefixSum[i] + arr[i]
        
        for i in range(n):
            step = 1
            while step + i <= n:
                right = i + step - 1
                res += prefixSum[right + 1] - prefixSum[i]
                step += 2
        
        return res

总结

  第一种暴力的空间复杂度是O(1)，因为只用到了几个int变量，第二种前缀和用到了额外的数组，所以空间复杂度是O(N)。关于进阶的思路，需要找到其中的数学规律，有一点复杂，建议感兴趣的伙伴自行查看官方题解。