剑指offer专项练习-数组中和为0的三个数&&和大于等于target的最短子数组&&乘积小于K的子数组

[剑指 Offer II 007. 数组中和为 0 的三个数]:https://leetcode-cn.com/problems/1fGaJU/

分析

006中的题目是在数组中找和为0的2个数字，因为数组已经是排序的，所以不需要排序，直接固定一个下标，然后再在剩余的当中去寻找对应的值

1. 这到题目当中数组是没有进行排序的所以首先第一步对其进行排序
2. 在固定变量i指向的数字之后，通过函数twosum来寻找是否存在下标大于i并且和为-num[i]
   1. 如果nums[j]+nums[k]>-nums[i]的时候k–
   2. 如果nums[j]+nums[k]<-nums[i]的时候j++
   3. 如果nums[j]+nums[k]=-nums[i]的时候，那么将j++，找到和等于-nums[i]的其它两个数字
3. 在找的过程中，题目当中有要求不能够重复，所以在函数当中我们要使用一个while循环来跳过与下标j相同的值，同时在threesum当中我们也要同样跳过与i相同的值

思路清晰写代码

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

// @solution-sync:begin
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int len=nums.size();
        vector<vector<int>>arr;
        if(len<3){
            return arr;
        }else {
            sort(nums.begin(),nums.end());
            int i=0;
            while(i<len-2){
                twosum(nums,i,arr);
                int temp=nums[i];
                while (i<len&&nums[i]==temp){
                    ++i;
                }
            }
        }
        return arr;
    }
private:
    void  twosum(vector<int>nums,int i,vector<vector<int>>&arr){
        int j=i+1;
        int k=nums.size()-1;
        while(j<k){
            if(nums[j]+nums[k]==-nums[i]){
                arr.push_back({nums[i],nums[j],nums[k]});
                int temp=nums[j];
                while(nums[j]==temp&&j<k){
                    ++j;
                }
            }else if(nums[i]+nums[j]+nums[k]<0){
                j++;
            }else {
                k--;
            }
        }
    }
};
// @solution-sync:end

#include <sstream>

string toString(vector<int> v) {
    stringstream out;
    out << "[";
    unsigned long size = v.size();
    for (int i = 0; i < size; ++i) {
        out << v[i];
        if (i < size - 1)
            out << ",";
    }
    out << "]";
    return out.str();
}
//函数的重载
string toString(vector<vector<int>> v) {
    stringstream out;
    out << "[";
    unsigned long size = v.size();
    for (int i = 0; i < size; ++i) {
        out << toString(v[i]);
        if (i < size - 1)
            out << ",";
    }
    out << "]";
    return out.str();
}

int main() {
    vector<int> nums = {-1, 0, 1, 2, -1, -4};

    auto solution = Solution();
    auto result = solution.threeSum(nums);
    cout << toString(result) << endl;

    return 0;
}

剑指 Offer II 008. 和大于等于 target 的最短子数组

分析

子数组由数组中一个或连续多个的数字组成，一个数组可以用两个指针来表示：

1. 第一个指针left指向第一个数子，第2个指针right指向子数组中最后一个数字，子数组就由这两个指针直接的所有数字组成
2. 让第2个指针right一直向右移动，直到当数组中的和大于或等于k的时候，那么将左指针向右移动一步，删除左边的一个数字
3. 如果两个指针直接的数字之和小于目标那么我们就将right向右移动
4. 那每次我们记录其长度，让后取最小长度就OK

话不多说上代码

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //首先定义一个count来保存其长度
        int count=10005;
        int len=nums.size();
        int left=0,right=0;
        int sum=0;
        while(right<len){
           //每次加上右端点的值
            sum+=nums[right];
            //如果左小于右端点，并且值满足条件，那么就将左端点向右移动一位，同时减去左端点的值
            //不满足条件的时候将右端点加1
            while(sum>=target&& left<=right){
                count= min(count,right-left+1);
                sum-=nums[left++];
            }
            right++;
        }
        return count==10005 ? 0:count;
    }
};

剑指 Offer II 009. 乘积小于 K 的子数组

分析

这道题和上一道题类似，那么跟上一个方法一样，左右指针

1. 当不断乘以右指针的值大于k的时候，那么除掉左指针的值，左指针++

2. 直到其满足条件的时候，右指针在++

3. 每次累加其值

   class Solution {
   public:
       int numSubarrayProductLessThanK(vector<int>& nums, int k) {
           int len=nums.size();
           long long  resualt=1;
           int left=0,right=0;
           int count=0;
           while(right<len){
               resualt*=nums[right];
               while(resualt>=k&&left<=right){
                   resualt/=nums[left++];
               }
               if(right>=left){
                   count+=right-left+1;
               }  
               right++; 
           }
           return count;
       }
   };