算法刷题日记2025/03/25——数组操作题目

Number One

题目描述

1. 0724 寻找数组的中心下标 分类：数组 标签：数学，前缀和
2. 给你一个整数数组 nums ，请计算数组的 中心下标 。
   数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
   如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
   如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

最初解题思路

将数组翻转后赋值给新数组，之后求两个数组的前缀和，最后通过双指针寻找中心坐标。空间复杂度：$O(n)$，时间复杂度：$O(n)$ 。
在写代码时突然明白，最后不用双指针，因为中心下标左右元素包含全部，因此两个数组的前缀和数组下标存在如下关系：start + end = n-1,且满足两个前缀和数组元素相等。

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        int n = nums.size();
        vector<int> flip_nums(nums.rbegin(), nums.rend());
        vector<int> prefix_nums(n),prefix_filp(n);
        prefix_nums[0] = nums[0];
        prefix_filp[0] = flip_nums[0];
        for(int i = 1; i < n; ++i){
            prefix_nums[i] = prefix_nums[i-1] + nums[i];
            prefix_filp[i] = prefix_filp[i-1] + flip_nums[i]; 
        }
        int start = 0, ans = -1;
        while(start < n){
            if(prefix_filp[n-start-1] == prefix_nums[start]){
                ans = start;
                break;
            }
            start++;
        }
        return ans;
    }
};

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        n: int = len(nums)
        filp_nums: List[int] = list(reversed(nums))
        prefix_nums: List[int] = [0] * n
        prefix_flip: List[int] = [0] * n
        prefix_nums[0] = nums[0]
        prefix_flip[0] = filp_nums[0]
        for i in range(1,n):
            prefix_nums[i] = prefix_nums[i-1] + nums[i]
            prefix_flip[i] = prefix_flip[i-1] + filp_nums[i]
        start: int = 0
        ans: int = -1
        while start < n:
            if prefix_nums[start] == prefix_flip[n-start-1]:
                ans = start
                break
            start += 1
        return ans

提交测试

1. 情况
   最终案例全部通过，不过在编写代码时遇到vector容器数组翻转初始化这一情况，最终也是查资料解决。 用时与消耗内存不大占优。
2. 分析
   

算法学习

记数组的全部元素之和为 $total$，当遍历到第 $i$ 个元素时，设其左侧元素之和为 $sum$，则其右侧元素之和为 $total-num{s}_i-sum$ 左右侧元素相等即为$sum=total-num{s}_i-sum$，即$2\times sum+num{s}_i=total$
当中心索引左侧或右侧没有元素时，即为零个项相加，这在数学上称作「空和」（empty sum）。在程序设计中我们约定「空和是零」。(力扣官方题解)
感悟：自己的解题思路还是偏直，没有想到左侧前缀和与右侧前缀和相加等于总数，以至于又将数组翻转再求一次前缀和。
空间复杂度：$O(1)$，时间复杂度：$O(n)$ 。

最终代码

1. C++

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        int total = accumulate(nums.begin(),nums.end(),0);
        int sum = 0;
        for(int i = 0; i < nums.size(); ++i){
            if(2*sum + nums[i] == total){
                return i;
            }
            sum += nums[i];
        }
        return -1;
    }
};

这里学习到一个C++求vector求和的方法accumulate。
accumulate(nums.begin(), nums.end(), 0);
accumulate带有三个形参：头两个形参指定要累加的元素范围，第三个形参则是累加的初值。
Python中求列表的和用sum()
2. Python

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        total: int = sum(nums)
        sums: int = 0
        for i in range(len(nums)):
            if(2*sums + nums[i] == total):
                return i
            sums = sums + nums[i]
        return -1

Number Two

题目描述

1. 0485 最大连续1的个数 分类：数组
2. 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

最初解题思路

暴力枚举，进行循环遍历，找到更大的连1就替换原来的结果。
空间复杂度：$O(1)$,时间复杂度：$O(n)$

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int ans = 0, tmp = 0;
        int n = nums.size();
        for(int i = 0; i < n; ++i){
            if(nums[i] == 1){
                tmp++;
            }
            else{
                tmp = 0;
            }
            if(tmp > ans){
                ans =tmp;
            }
        }
        return ans;
    }
};

提交测试

1. 情况
   

2. 分析
   没错就是这么简单，这道题没有什么算法知识可学习的。

Number Three

题目描述

1. 0238 除自身以外数组的乘积 分类：数组 标签：前缀和
2. 给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
   题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
   请不要使用除法，且在 O(n) 时间复杂度内完成此题。

最初解题思路

题目明确给出不要使用除法，以及在$O(n)$完成此题，因此我也是毫无思路，一下子把我的武器库清空了，直接学习题解的算法，尝试能否自己复刻算法思路。
将数组翻转，求左侧和右侧的前缀积，之后根据索引求出左侧与右侧的乘积得到答案。（与Number One那道题寻找数组中心下标，求左右和有异曲同工之妙）

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> L(n), R(n);
        vector<int> filp(nums.rbegin(),nums.rend());
        L[0] = 1; R[0] = 1;
        for(int i = 1; i < n; ++i){
            L[i] = L[i-1] * nums[i-1];
            R[i] = R[i-1] * filp[i-1]; 
        }
        vector<int> ans(n);
        for(int i = 0; i < n; ++i){
            ans[i] = L[i] * R[n-1-i];
        }
        return ans;
    }
};

提交测试

1. 情况
   
2. 分析
   前缀和思想，不过采用的是前缀积。

算法学习

空间复杂度 O(1) 的方法

尽管上面的方法已经能够很好的解决这个问题，但是空间复杂度并不为常数。
由于输出数组不算在空间复杂度内，那么我们可以将 L 或 R 数组用输出数组来计算。先把输出数组当作 L 数组来计算，然后再动态构造 R 数组得到结果。让我们来看看基于这个思想的算法。(力扣官方题解)

代码实现

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n);
        ans[0] = 1;
        for(int i = 1; i < n; ++i){
            ans[i] = ans[i-1] * nums[i-1];
        }
        int tmp = nums[n-1],mid;
        nums[n-1] = 1;
        for(int i = n-2; i >= 0; --i){
            mid = nums[i+1] * tmp;
            tmp = nums[i];
            nums[i] = mid;
        }
        for(int i = 0; i < n; ++i){
            ans[i] = ans[i] * nums[i];
        }
        return ans;
    }
};

//官方题解
class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();
        vector<int> answer(length);

        // answer[i] 表示索引 i 左侧所有元素的乘积
        // 因为索引为 '0' 的元素左侧没有元素， 所以 answer[0] = 1
        answer[0] = 1;
        for (int i = 1; i < length; i++) {
            answer[i] = nums[i - 1] * answer[i - 1];
        }
        // R 为右侧所有元素的乘积
        // 刚开始右边没有元素，所以 R = 1
        int R = 1;
        for (int i = length - 1; i >= 0; i--) {
            // 对于索引 i，左边的乘积为 answer[i]，右边的乘积为 R
            answer[i] = answer[i] * R;
            // R 需要包含右边所有的乘积，所以计算下一个结果时需要将当前值乘到 R 上
            R *= nums[i];
        }
        return answer;
    }
};

在算法优化过程中，如果想要减少空间复杂度，可以优先考虑使用结果数组存储中间状态，或者直接利用原来数组，迭代生成新数组覆盖原来数组。