剑指Offer(专项突击版) - 01

剑指 Offer II 006. 排序数组中两个数字之和⭐️

给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 0 开始计数 ，所以答案数组应当满足 0 <= answer[0] < answer[1] < numbers.length 。

假设数组中存在且只存在一对符合条件的数字，同时一个数字不能使用两次。

示例1

输入：numbers = [1,2,4,6,10], target = 8
输出：[1,3]
解释：2 与 6 之和等于目标数 8 。因此 index1 = 1, index2 = 3 。

示例2

输入：numbers = [2,3,4], target = 6
输出：[0,2]

示例3

输入：numbers = [-1,0], target = -1
输出：[0,1]

提示

• 2 <= numbers.length <= 3 * 104
• -1000 <= numbers[i] <= 1000
• numbers 按 递增顺序 排列
• -1000 <= target <= 1000
• 仅存在一个有效答案

题解

1.对撞双指针

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int left = 0, right = numbers.length - 1;
        while(left < right) {
            int sum = numbers[left] + numbers[right];
            if(sum < target) left++;
            else if(sum > target) right--;
            else return new int[] { left, right };
        }
        return new int[0];
    }
}

剑指 Offer II 007. 数组中和为 0 的三个数⭐️⭐️

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a ，b ，c ，使得 a + b + c = 0 ？请找出所有和为 0 且 不重复 的三元组。

示例1

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

示例2

输入：nums = []
输出：[]

示例3

输入：nums = [0]
输出：[]

提示

• 0 <= nums.length <= 3000
• -105 <= nums[i] <= 105

题解

1.排序 + 双指针

利用移项将三数和转换为两数和，即指针 first 从开头开始移动，使 target = -nums[first]

​ 然后在将 first 之后的部分看作一个整体，利用 对撞指针 完成求和检测

​ 这里需要注意的一个重点是 不可重复，直接看题解的解释吧：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        for(int first = 0; first < n; ++first) {
            if(first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            int third = n - 1;
            int target = -nums[first];
            for(int second = first + 1; second < n; ++second) {
                if(second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                while(second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    List<Integer> list = new ArrayList<Integer>();
                    list.add(nums[first]);
                    list.add(nums[second]);
                    list.add(nums[third]);
                    result.add(list);
                }
            }
        }
        return result;
    }
}

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

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例1

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例2

输入：target = 4, nums = [1,4,4]
输出：1

示例3

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示

• 1 <= target <= 109
• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

题解

1.滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int minLength = Integer.MAX_VALUE;
        for(int right = 0; right < nums.length; ++right) {
            sum += nums[right];
            while(left <= right && sum >= target) {
                minLength = Math.min(minLength, right - left + 1);
                sum -= nums[left++];
            }
        }
        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }
}

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

给定一个正整数数组 nums和整数 k ，请找出该数组内乘积小于 k 的连续的子数组的个数。

示例1

输入: nums = [10,5,2,6], k = 100
输出: 8
解释: 8 个乘积小于 100 的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于100的子数组。

示例2

输入: nums = [1,2,3], k = 0
输出: 0

提示

• 1 <= nums.length <= 3 * 104
• 1 <= nums[i] <= 1000
• 0 <= k <= 106

题解

1.滑动窗口

注意这里统计的是满足条件的总数

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        int left = 0;
        int result = 1;
        int count = 0;
        for(int right = 0; right < nums.length; ++right) {
            result *= nums[right];
            while(left <= right && result >= k) {
                result /= nums[left++];
            }
            count += right >= left ? right - left + 1 : 0;
        }
        return count;
    }
}

剑指 Offer II 010. 和为 k 的子数组⭐️⭐️

给定一个整数数组和一个整数 k **，**请找到该数组中和为 k 的连续子数组的个数。

示例1

输入:nums = [1,1,1], k = 2
输出: 2
解释: 此题 [1,1] 与 [1,1] 为两种不同的情况

示例2

输入:nums = [1,2,3], k = 3
输出: 2

提示

• 1 <= nums.length <= 2 * 104
• -1000 <= nums[i] <= 1000
• -107 <= k <= 107

题解

1.枚举

两层循环做双指针

public class Solution {
    public int subarraySum(int[] nums, int k) {
        int count = 0;
        for (int start = 0; start < nums.length; ++start) {
            int sum = 0;
            for (int end = start; end >= 0; --end) {
                sum += nums[end];
                if (sum == k) {
                    count++;
                }
            }
        }
        return count;
    }
}

2.前缀和 + 哈希表

分析

假设整个数组的长度为 n，其中某个子数组的左右下标分别为 i、j，现在想求 S

假设从下标 0 到下标 i 的子数组之和为 Si，从下标 0 到下标 j 的子数组之和为 Sj，则 S = Sj - Si

思路

由上述分析，想要统计和为 k 的子数组个数，也就是统计 Sj - Si = k，移项得 Si = Sj - k

因此可以维护一个 Map，key 存储 Si，value 存储对应的个数，当统计和为 k 的子数组个数时，仅需要找出 Sj - k 对应的个数即可

class Solution {
    public int subarraySum(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        // key 为 sum - k，value 为 个数
        map.put(0, 1);
        int sum = 0;
        int count = 0;
        for(int i = 0; i < nums.length; ++i) {
            sum += nums[i];
            count += map.getOrDefault(sum - k, 0);
            map.put(sum, map.getOrDefault(sum, 0) + 1);
        }
        return count;
    }
}