【LeetCode】数组精选17题——双指针、滑动窗口、前缀和

发布时间:2023年12月17日

目录

快慢指针:

1. 移动零(简单)

2. 复写零(简单)

对撞指针:

1. 两数之和 II - 输入有序数组(中等)

2. 三数之和(中等)

3. 有效三角形的个数(中等)

4. 四数之和(中等)

5. 盛最多水的容器(中等)

滑动窗口:

1. 长度最小的子数组(中等)

2.?将 x 减到 0 的最小操作数(中等)

3.?乘积小于 K 的子数组(中等)

4. 最大连续1的个数 III(中等)

5. 水果成篮(中等)

前缀和:

1. 寻找数组的中心下标(简单)

2. 和为 K 的子数组(中等)

3. 连续数组(中等)

4. 二维区域和检索 - 矩阵不可变(中等)

5. 矩阵区域和(中等)


双指针是一种常用的算法技巧,通常用于线性数据结构(数组、字符串、链表),使用两个指针扫描。指针并不是指C语言中的指针,而是指能定位数据结构中某个数据的手段,在数组中指的是下标。

双指针的形式:

  • 快慢指针:两个指针从一端向另一端移动,但移动速度不同
  • 对撞指针:两个指针从两端向中间移动,直到相遇或错开

滑动窗口是一种特殊的双指针,两个指针构造一个窗口,用于解决子数组的问题。右边界右移为进窗口,左边界右移为出窗口。

正数数组中子数组的和或积,就可以用滑动窗口解决。如果数组元素不全为正数,求子数组的和不能用滑动窗口,因为当数组中有负数时在子数组中添加数字不一定能增加数组之和,从子数组中删除数字也不一定能减少子数组之和。这时就需要用到前缀和思想。

快慢指针:

1. 移动零(简单)

数组分块问题,即根据一种划分方式,将数组分成两块,可以使用双指针解决。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size();
        int slow = -1; // 指向非0元素的最后一个
        int fast = 0;  // 指向待处理元素的第一个

        while (fast < n)
        {
            if (nums[fast] == 0) // fast扫描到0
            {
                fast++;
            }
            else // fast扫描到非0
            {
                swap(nums[++slow], nums[fast]);
                fast++;
            }
        }
    }
};

2. 复写零(简单)

如果从前往后原地复写0的话,会导致后面的元素被覆盖。例如,[2,0,5,1]? ? ->? ? [2,0,0,1]

所以本题采用从后往前复写0,首先要找到原数组从哪里截断。

当fast = n - 1时,说明数组给待处理元素剩的位置只有1个了,这个位置就是留给slow的,不管arr[slow]是0还是非0。将arr[slow]填到数组最后一个位置,然后从slow - 1开始从后往前复写。

当fast = n时,说明数组给待处理元素已经不剩位置了,并且fast一定是从n - 2位置走两步到n,所以上一步的slow一定指向0,然后写了2个0,到达数组末尾。将0填到数组最后一个和倒数第二个位置,然后从slow-2开始从后往前复写。

class Solution {
public:
    void duplicateZeros(vector<int>& arr) {
        int n = arr.size();
        int slow = 0;
        int fast = 0;
        // 找到截断点
        while (fast < n - 1)
        {
            // slow指向待处理元素的第一个
            // fast表示,如果发生复写,待处理元素的第一个的真正的位置
            if (arr[slow])
            {
                fast++;
            }
            else
            {
                fast +=2;
            }
            slow++;
        }
        // 判断fast,然后让slow指向待处理元素的第一个,fast表示待处理位置的第一个
        if (fast == n - 1)
        {
            arr[n - 1] = arr[slow];
            slow--;
            fast--;
        }
        else
        {
            arr[n - 1] = arr[n - 2] = 0;
            slow -= 2;
            fast -= 3;
        }
        // 从后往前复写
        while (slow >= 0)
        {
            if (arr[slow])
            {
                arr[fast] = arr[slow];
                fast--;
            }
            else
            {
                arr[fast] = arr[fast - 1] = 0;
                fast -= 2;
            }
            slow--;
        }
    }
};

对撞指针:

1. 两数之和 II - 输入有序数组(中等)

对撞指针的应用之一就是求排序数组的两个数字之和。如果和 < 目标值,左指针++,如果和 > 目标值,右指针--,直到和 == 目标值,就找到了那两个数。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int n = numbers.size();
        int left = 0;
        int right = n - 1;
        while (left < right)
        {
            if (numbers[left] + numbers[right] < target)
            {
                left++;
            }
            else if (numbers[left] + numbers[right] > target)
            {
                right--;
            }
            else
            {
                return { ++left,++right }; // 因为下标从1开始
            }
        }
        return { -1,-1 };
    }
};

2. 三数之和(中等)

和两数之和类似,如果是排序数组,那么固定nums[i],用对撞指针从i的后面找nums[left] + nums[right] == -nums[i]。

答案不能有重复,所以要在找到一种答案后,跳过重复的元素。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        
        for (int i = 0; i < n - 2; )
        {
            int left = i + 1;
            int right = n - 1;
            while (left < right)
            {
                if (nums[left] + nums[right] < -nums[i])
                {
                    left++;
                }
                else if (nums[left] + nums[right] > -nums[i])
                {
                    right--;
                }
                else
                {
                    ans.push_back({ nums[i],nums[left++],nums[right--] });
                    // 去重left
                    while (left < right && nums[left] == nums[left - 1])
                    {
                        left++;
                    }
                    // 去重right
                    while (left < right && nums[right] == nums[right + 1])
                    {
                        right--;
                    }
                }
            }
            i++;
            // 去重i
            while (i < n - 2 && nums[i] == nums[i - 1])
            {
                i++;
            }
        }
        return ans;
    }
};

3. 有效三角形的个数(中等)

三角形的判定:任意两边之和大于第三边。

只要两条较短边>最长边,就可以推出任意两边之和大于第三边。

和三数之和类似,先给数组排序,固定最长边nums[i],用对撞指针从i的前面找nums[left] + nums[right] > nums[i]。

一旦向右移动left到某个位置时nums[left] + nums[right] > nums[i],就不需要再向右移动left了。因为只要保持right不动,[left, right)这个下标区间对应的任意一个元素,加上nums[right],都一定比nums[i]大。此时两个指针之间有多少个数字,就找到了多少组两条较短边>最长边。

答案可以有重复,不用跳过重复的元素。

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        int ans = 0;

        for (int i = n - 1; i >= 2; i--)
        {
            int left = 0;
            int right = i - 1;
            while (left < right)
            {
                if (nums[left] + nums[right] > nums[i])
                {
                    ans += right - left;
                    right--;
                }
                else
                {
                    left++;
                }
            }
        }
        return ans;
    }
};

4. 四数之和(中等)

先排序,固定一个数nums[a],再利用三数之和的解法找到三个数nums[b] nums[c] nums[d],使

nums[b] + nums[c] + nums[d] == target - nums[a]。

答案不能有重复,所以要在找到一种答案后,跳过重复的元素。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        
        for (int i = 0; i < n - 3; ) // 固定nums[i]
        {
            for (int j = i + 1; j < n - 2; ) // 固定nums[j]
            {
                int sum1 = nums[i] + nums[j];
                int left = j + 1;
                int right = n - 1;
                while (left < right)
                {
                    int sum2 = nums[left] + nums[right];
                    if (sum2 < (long long)target - sum1)
                    {
                        left++;
                    }
                    else if (sum2 > (long long)target - sum1)
                    {
                        right--;
                    }
                    else
                    {
                        ans.push_back({ nums[i],nums[j],nums[left++],nums[right--] });
                        // 去重left
                        while (left < right && nums[left] == nums[left - 1])
                        {
                            left++;
                        }
                        // 去重right
                        while (left < right && nums[right] == nums[right + 1])
                        {
                            right--;
                        }
                    }
                }
                j++;
                // 去重j
                while (j < n - 2 && nums[j] == nums[j - 1])
                {
                    j++;
                }
            }
            i++;
            // 去重i
            while (i < n - 3 && nums[i] == nums[i - 1])
            {
                i++;
            }
        }
        return ans;
    }
};

5. 盛最多水的容器(中等)

假设左板的下标是left,右板的下标是right,两板与x轴构成的矩形的面积为:

S = (right - left) * min(height[left], height[right])

显然,矩形的面积由底边宽度和短板长度共同决定。

如果改变短板,向内收窄一格,底边宽度-1,短板的长度可能会变大,矩形的面积可能变大。

如果改变长板,向内收窄一格,底边宽度-1,由于短板决定高度,长板再怎么改变也没有用,矩形的面积一定变小。

class Solution {
public:
    int maxArea(vector<int>& height) {
        int n = height.size();
        int left = 0;
        int right = n - 1;
        int ans = 0;
        while (left < right)
        {
            ans = max(ans, ((right - left) * min(height[left], height[right])));
            if (height[left] < height[right])
            {
                left++;
            }
            else
            {
                right--;
            }
        }
        return ans;
    }
};

滑动窗口:

1. 长度最小的子数组(中等)

进窗口后判断子数组的和是否>= target,如果找到了和>= target的子数组,更新结果,然后出窗口,缩小子数组的长度,直到子数组的和 < target。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        int left = 0;
        int right = 0;
        int sum = 0;
        int ans = INT_MAX;
        while (right < n)
        {
            // 进窗口
            sum += nums[right];
            // 判断子数组的和是否>=target
            while (sum >= target && left <= right)
            {
                // 更新结果
                ans = min(ans, right - left + 1);
                // 出窗口
                sum -= nums[left++];
            }
            // 更新右边界
            right++;
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

2.?将 x 减到 0 的最小操作数(中等)

问题可以理解成:求和为x的最左端子数组和最右端子数组的最小长度。

把问题转化成:求和为total - x的子数组的最大长度(total为数组所有元素的和)。

这道题nums[i]的取值范围是:1 <= nums[i] <= 104,求正数数组中子数组的和,显然用滑动窗口。

进窗口后判断子数组的和是否> total - x,如果已经> total - x了,要出窗口,减小子数组的和,直<= total - x。然后判断子数组的和到底是不是==?total - x,如果找到了和==?total - x的子数组,更新结果。

class Solution {
public:
    int minOperations(vector<int>& nums, int x) {
        int n = nums.size();
        int total = 0;
        for (auto& e : nums)
        {
            total += e;
        }

        int left = 0;
        int right = 0;
        int sum = 0;
        int ans = -1;
        while (right < n)
        {
            // 进窗口
            sum += nums[right];
            // 判断子数组的和是否>total-x
            while (sum > total - x && left <= right)
            {
                // 出窗口
                sum -= nums[left++];
            }
            // 找到和为total-x的子数组,更新结果
            if (sum == total - x)
            {
                ans = max(ans, right - left + 1);
            }
            // 更新右边界
            right++;
        }
        return ans == -1 ? ans : n - ans;
    }
};

3.?乘积小于 K 的子数组(中等)

进窗口后判断子数组的积是否>= k,如果已经 >= k了,要出窗口,减小子数组的积,直到< k。这时得到的子数组就是满足条件的子数组,并且,只要保持右边界不动,向右移动左边界形成的所有子数组的积就一定< k。此时左右边界之间有多少个元素,就找到了多少个乘积< k的子数组。

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int n = nums.size();
        int left = 0;
        int right = 0;
        int prod = 1;
        int ans = 0;
        while (right < n)
        {
            // 进窗口
            prod *= nums[right];
            // 判断子数组的积是否>=k
            while (prod >= k && left <= right)
            {
                // 出窗口
                prod /= nums[left++];
            }
            // 更新结果
            ans +=  right - left + 1;
            // 更新右边界
            right++;
        }
        return ans;
    }
};

4. 最大连续1的个数 III(中等)

把问题转化成:求0的个数不超过k个的最长子数组。

用zero记录窗口中0的个数。进窗口的同时要维护zero,然后判断zero是否> k,如果已经> k了,要出窗口并维护zero,直到<= k。这时就找到了0的个数不超过k个的子数组,更新结果。

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int n = nums.size();
        int left = 0;
        int right = 0;
        int zero = 0; // 窗口中0的个数
        int ans = 0;
        while (right < n)
        {
            // 进窗口+维护zero
            if (nums[right] == 0)
                zero++;
            // 判断zero是否>k
            while (zero > k && left <= right)
            {
                // 出窗口+维护zero
                if (nums[left] == 0)
                {
                    zero--;
                }
                left++;
            }
            // 更新结果
            ans = max(ans, right - left + 1);
            // 更新右边界
            right++;
        }
        return ans;
    }
};

5. 水果成篮(中等)

把问题转化成:求元素的种类只有2种的最长子数组。

用哈希表记录窗口中元素的种类和次数,key——元素的种类,value——每个元素出现的次数,哈希表的大小表示有多少种元素在窗口中。

进窗口后判断哈希表的大小是否> 2,如果已经> 2了,要出窗口,记得要把value为0的键值对删除,直到哈希表的大小== 2。这时就找到了元素的种类只有2种的子数组,更新结果。

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size();
        int left = 0;
        int right = 0;
        unordered_map<int, int> hash; // key——元素的种类,value——每个元素出现的次数
        int ans = 0;
        while (right < n)
        {
            // 进窗口
            hash[fruits[right]]++;
            // 判断哈希表的大小是否>2
            while (hash.size() > 2 && left <= right)
            {
                // 出窗口
                hash[fruits[left]]--;
                if (hash[fruits[left]] == 0)
                {
                    hash.erase(fruits[left]);
                }
                left++;
            }
            // 更新结果
            ans = max(ans, right - left + 1);
            // 更新右边界
            right++;
        }
        return ans;
    }
};

前缀和:

1. 寻找数组的中心下标(简单)

如果sum - nums[i] == total - sum,i就是中心下标。

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        int n = nums.size();
        int total = 0; // 所有元素的和
        for (auto& i : nums)
        {
            total += i;
        }
        int sum = 0; // 表示左子数组的和+nums[i]
        for (int i = 0; i < n; i++)
        {
            sum += nums[i];
            if (sum - nums[i] == total - sum)
                return i;
        }
        return -1;
    }
};

2. 和为 K 的子数组(中等)

每次累加新的前缀和,都往前找找有没有以前的前缀和 == 新的前缀和 - k。

用哈希表记录前缀和出现的次数,默认添加一个键值对(0, 1)。用sum表示当前位置的前缀和。

例如,nums = [3,2,1],k = 3,

将nums[0]添加进sum,sum = 3,sum - k = 0,恰好哈希表中存放了值为0的前缀和,出现的次数为1,将出现的次数添加进ans中,ans = 1。然后把当前位置的前缀和在哈希表中对应的值++,此时哈希表中有2个键值对:(0, 1), (3, 1)。

将nums[1]添加进sum,sum = 5,sum - k = 2,哈希表中没有存放值为2的前缀和,没找到满足条件的子数组,对ans不做处理。然后把当前位置的前缀和在哈希表中对应的值++,此时哈希表中有3个键值对:(0, 1), (3, 1), (5, 1)。

将nums[2]添加进sum,sum = 6,sum - k = 3,恰好哈希表中存放了值为3的前缀和,出现的次数为1,将出现的次数添加进ans中,ans = 2。然后把当前位置的前缀和在哈希表中对应的值++,此时哈希表中有4个键值对:(0, 1), (3, 1), (5, 1), (6, 1)。

循环结束,输出ans。

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {      
        int n = nums.size();
        unordered_map<int, int> hash; // key——前缀和 value——出现的次数
        hash[0] = 1; // 添加(0, 1)
        int sum = 0; // 当前位置的前缀和
        int ans = 0;
        for (auto& i : nums)
        {
            sum += i;
            if (hash.count(sum - k))
            {
                ans += hash[sum - k];
            }
            hash[sum]++;
        }
        return ans;
    }
};

3. 连续数组(中等)

把数组所有0替换成-1,题目转变为:找到和为0的最长连续子数组。

每次累加新的前缀和,都往前找找有没有以前的前缀和 == 新的前缀和。

用哈希表记录前缀和对应的最小下标(因为求最大子数组),默认添加一个键值对(0, -1)。用sum表示当前位置的前缀和。

例如,nums = [0,1,0],

将nums[0]添加进sum,如果是0,添加-1,如果是1,添加1,sum = -1,哈希表中没有存放值为-1的前缀和,没找到满足条件的子数组,对ans不做处理。然后把当前位置的前缀和及下标添加进哈希表中,此时哈希表中有2个键值对:(0, -1), (-1, 0)。

将nums[1]添加进sum,如果是0,添加-1,如果是1,添加1,sum = 0,恰好哈希表中存放了值为0的前缀和,下标为-1,所以子数组长度为1 - (-1) = 2,将它和ans比较,取最大的,ans = 2。

将nums[2]添加进sum,如果是0,添加-1,如果是1,添加1,sum = -1,恰好哈希表中存放了值为-1的前缀和,下标为0,所以子数组长度为2 - 0 = 2,将它和ans比较,取最大的,ans = 2。

循环结束,输出ans。

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int n = nums.size();
        unordered_map<int, int> hash; // key——前缀和 value——最小下标
        hash[0] = -1; // 添加(0, -1)
        int sum = 0; // 当前位置的前缀和
        int ans = 0;
        for (int i = 0; i < n; i++)
        {
            sum += nums[i] == 0 ? -1 : 1;
            if (hash.count(sum))
            {
                ans = max(ans, i - hash[sum]);
            }
            else
            {
                hash[sum] = i;
            }
        }
        return ans;
    }
};

4. 二维区域和检索 - 矩阵不可变(中等)

创建一个和matrix一样大的二维前缀和数组sums,sums[i][j]记录matrix从(0,0)到(i,j)的子矩阵数字和。

(r1,c1)->(r2,c2)子矩阵数字和 =

sums[r2][c2] - sums[r2][c1 - 1] - sums[r1 - 1][c2] + sums[r1 - 1][c1 - 1]

如果r1或c1为0,r1 - 1或c1 - 1会越界。

为了防止越界,在sums的上面和左面分别加一行0和一列0,这样的话,sums[i+1][j+1]记录matrix从(0,0)到(i,j)的子矩阵数字和。

所以,(r1,c1)->(r2,c2)子矩阵数字和 =

sums[r2 + 1][c2 + 1] - sums[r2 + 1][c1] - sums[r1][c2 + 1] + sums[r1][c1]

class NumMatrix {
public:
    public:
    NumMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        sums.resize(m + 1, vector<int>(n + 1, 0)); // 上面和左面分别加一行0和一列0,防止越界
        // 处理前缀和数组
        for (int i = 0; i < m; i++)
        {
            int rowSum = 0;
            for (int j = 0; j < n; j++)
            {
                rowSum += matrix[i][j];
                sums[i + 1][j + 1] = sums[i][j + 1] + rowSum;
            }
        }
    }
    
    int sumRegion(int row1, int col1, int row2, int col2) {
        return sums[row2 + 1][col2 + 1] - sums[row2 + 1][col1] - sums[row1][col2 + 1] + sums[row1][col1];
    }

private:
    vector<vector<int>> sums; // sums[i+1][j+1]记录matrix从(0,0)到(i,j)的子矩阵数字和
};

5. 矩阵区域和(中等)

和上一题“二维矩阵区域和检索 - 矩阵不可变”类似。

注意矩阵左上角和右下角坐标的确定:

  • 左上角:r1 = max(0, i - k)? ? ? ? ? c1 = max(0, j - k)
  • 右下角:r2 = min(m - 1, i + k)? ? c2 = min(n - 1, j + k)
class Solution {
public:
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        int m = mat.size();
        int n = mat[0].size();

        // 处理前缀和矩阵
        vector<vector<int>> sums(m + 1, vector<int>(n + 1, 0)); // sums[i+1][j+1]记录matrix从(0,0)到(i,j)的子矩阵数字和
        for (int i = 0; i < m; i++)
        {
            int rowSum = 0;
            for (int j = 0; j < n; j++)
            {
                rowSum += mat[i][j];
                sums[i + 1][j + 1] = sums[i][j + 1] + rowSum;
            }
        }

        // 处理ans矩阵
        vector<vector<int>> ans(m, vector<int>(n));
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                int r1 = max(0, i - k);
                int c1 = max(0, j - k);
                int r2 = min(m - 1, i + k);
                int c2 = min(n - 1, j + k);
                ans[i][j] = sums[r2 + 1][c2 + 1] - sums[r2 + 1][c1] - sums[r1][c2 + 1] + sums[r1][c1];
            }
        }
        return ans;
    }
};
文章来源:https://blog.csdn.net/Qiuhan_909/article/details/134860354
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。