1.双指针【灵神基础精讲】

来源0x3f：https://space.bilibili.com/206214

同向双指针

209. 长度最小的子数组

难度中等1559

给定一个含有 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

进阶：

• 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

//零神的写法
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0, right = 0;
        int res = Integer.MAX_VALUE;
        int sum = 0;
        while(right < nums.length){
            sum += nums[right];
            right++;
            // 满足单调性下 条件由成立变为不成立
            while(sum - nums[left] >= target){
                sum -= nums[left];
                left++;
            }
            if(sum >= target){
                res = Math.min(res, right - left);
            }
        }
        return res == Integer.MAX_VALUE ? 0 : res;
    }
}
// -----------------------------------------------------------------
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0, right = 0;
        int res = Integer.MAX_VALUE;
        int sum = 0;
        while(right < nums.length){
            sum += nums[right];
            right++;
            while(sum >= target){
                res = Math.min(res, right - left);
                sum -= nums[left];
                left++;
            }
        }
        return res == Integer.MAX_VALUE ? 0 : res;
    }
}

713. 乘积小于 K 的子数组

难度中等646

给你一个整数数组 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

class Solution {
    public int numSubarrayProductLessThanK(int[] nums, int k) {
        if(k == 0) return 0;
        int left = 0, right = 0;
        int res = 0;
        int mul = 1;
        while(right < nums.length){
            mul *= nums[right];
            right++;
            while(left < right && mul >= k){
                mul /= nums[left];
                left++;
            }
            // 子数组个数的计算方法：
            // 移动到right时 以right为右端点的满足要求的子数组个数
            res += (right-left);
        }
        return res;
    }
}

3. 无重复字符的最长子串

难度中等8709

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

• 0 <= s.length <= 5 * 104
• s 由英文字母、数字、符号和空格组成

class Solution {
    public int lengthOfLongestSubstring(String S) {
        char[] s = S.toCharArray(); // 转换成 char[] 加快效率（忽略带来的空间消耗）
        int n = s.length, ans = 0;
        int right = 0, left = 0;
        int[] cnt = new int[128];
        while(right < n) {
            char c = s[right];
            ++cnt[c];
            right++;
            while (cnt[c] > 1) // 不满足要求
                --cnt[s[left++]];
            ans = Math.max(ans, right - left);
        }
        return ans;
    }
}

---

1004. 最大连续1的个数 III

难度中等509

给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。

示例 1：

输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释：[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。

示例 2：

输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。

提示：

• 1 <= nums.length <= 105
• nums[i] 不是 0 就是 1
• 0 <= k <= nums.length

class Solution {
    public int longestOnes(int[] nums, int k) {
        int res = 0;
        int left = 0, right = 0;
        int cnt = 0;
        while(right < nums.length){
            if(nums[right] == 0) cnt++;
            right++;
            while(cnt > k){
                if(nums[left] == 0) cnt--;
                left++;
            }
            res = Math.max(res, right-left);
        }
        return res;
    }
}

---

1234. 替换子串得到平衡字符串

难度中等222

有一个只含有 'Q', 'W', 'E', 'R' 四种字符，且长度为 n 的字符串。

假如在该字符串中，这四个字符都恰好出现 n/4 次，那么它就是一个「平衡字符串」。

给你一个这样的字符串 s，请通过「替换一个子串」的方式，使原字符串 s 变成一个「平衡字符串」。

你可以用和「待替换子串」长度相同的 任何 其他字符串来完成替换。

请返回待替换子串的最小可能长度。

如果原字符串自身就是一个平衡字符串，则返回 0。

示例 1：

输入：s = "QWER"
输出：0
解释：s 已经是平衡的了。

示例 2：

输入：s = "QQWE"
输出：1
解释：我们需要把一个 'Q' 替换成 'R'，这样得到的 "RQWE" (或 "QRWE") 是平衡的。

示例 3：

输入：s = "QQQW"
输出：2
解释：我们可以把前面的 "QQ" 替换成 "ER"。 

示例 4：

输入：s = "QQQQ"
输出：3
解释：我们可以替换后 3 个 'Q'，使 s = "QWER"。

提示：

• 1 <= s.length <= 10^5
• s.length 是 4 的倍数
• s 中只含有 'Q', 'W', 'E', 'R' 四种字符

class Solution {
    public int balancedString(String s) {
        //只需要窗口外每种字符的数目小于等于平均值即可
        int[] count = new int[26];
        int len = s.length();
        for(int i = 0; i < len; i++){
            count[s.charAt(i) - 'A']++;
        }
        int left = 0, right = 0;
        int res = len;
        int average = len / 4;

        while(right < len){
            //滑动窗口里进来一个元素 就把count里的这个值减1
            count[s.charAt(right) - 'A']--;
            //如果四个元素都符合要求 就计算最小值
            while(left < len && 
                count['Q'-'A'] <= average && count['W'-'A'] <= average && count['E'-'A'] <= average && count['R'-'A'] <= average){
                    res = Math.min(res, right - left + 1);
                    count[s.charAt(left) - 'A']++;
                    left++;
                }
            right++;
        }
        return res;
    }
}

---

相向双指针

167. 两数之和 II - 输入有序数组

难度中等981

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

示例 2：

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

示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。

提示：

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

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

更加简洁的写法

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

---

15. 三数之和

难度中等5631

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

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

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        for(int i = 0; i < nums.length-2; i++){
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i+1, right = nums.length-1;
            while(left < right){
                int sum = nums[i] + nums[left] + nums[right];
                if(sum == 0){
                    List<Integer> tmp = new ArrayList<>();
                    tmp.add(nums[i]);tmp.add(nums[left]);tmp.add(nums[right]);
                    res.add(tmp);
                    left += 1;
                    while(left < nums.length && nums[left] == nums[left-1]) left += 1;
                    right -= 1;
                    while(right > 0 && nums[right] == nums[right+1]) right -= 1;
                }else if(sum > 0){
                    right--;
                }else{
                    left++;
                }
            }
        }
        return res;
    }
}

---

16. 最接近的三数之和

难度中等1332

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

示例 2：

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

提示：

• 3 <= nums.length <= 1000
• -1000 <= nums[i] <= 1000
• -104 <= target <= 104

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int res = nums[0] + nums[1] + nums[2];
        for(int i = 0; i < nums.length-2; i++){
            int left = i+1, right = nums.length-1;
            while(left < right){
                int sum = nums[i] + nums[left] + nums[right];
                if(Math.abs(res-target) > Math.abs(sum-target)){
                    res = sum;
                }
                if(sum == target){
                    return sum;
                }else if(sum > target){
                    right--;
                }else{
                    left++;
                }
            }
        }
        return res;
    }
}

---

611. 有效三角形的个数

难度中等471

给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。

示例 1:

输入: nums = [2,2,3,4]
输出: 3
解释:有效的组合是: 
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3

示例 2:

输入: nums = [4,2,3,4]
输出: 4

提示:

• 1 <= nums.length <= 1000
• 0 <= nums[i] <= 1000

class Solution {
    public int triangleNumber(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        int res = 0;
        for(int i = 2; i < n; i++){
            int left = 0, right = i-1;
            while(left < right){
                if(nums[left] + nums[right] > nums[i]){
                    res += right-1 - left + 1; // 从i r 和 l到r-1都可组成三角形
                    right--;
                }
                else left++;
            }
        }
        return res;
    }
}

---

11. 盛最多水的容器

难度中等4081

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明：**你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

• n == height.length
• 2 <= n <= 105
• 0 <= height[i] <= 104

class Solution {
    public int maxArea(int[] height) {
        int res = 0;
        int n = height.length;
        int left = 0, right = n-1;
        while(left < right){
            int area = (right-left) * Math.min(height[left], height[right]);
            res = Math.max(res, area);
            if(height[left] < height[right]) left++;
            else right--;
        }
        return res;
    }
}

---

42. 接雨水

难度困难4100

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示：

• n == height.length
• 1 <= n <= 2 * 104
• 0 <= height[i] <= 105

双指针做法

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int res = 0;
        int left = 0, right = n-1;
        int premax = 0, sufmax = 0;
        while(left <= right){
            premax = Math.max(premax, height[left]);
            sufmax = Math.max(sufmax, height[right]);
            if(premax < sufmax){
                res += premax - height[left];
                left += 1;
            }else{
                res += sufmax - height[right];
                right -= 1;
            }
        }
        return res;
    }
}

前后缀分解

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int[] premax = new int[n];
        premax[0] = height[0];
        for(int i = 1; i < n; i++){
            premax[i] = Math.max(premax[i-1], height[i]);
        }
        int[] sufmax = new int[n];
        sufmax[n-1] = height[n-1];
        for(int i = n-2; i >= 0; i--){
            sufmax[i] = Math.max(sufmax[i+1], height[i]);
        }
        int res = 0;
        for(int i = 0; i < n; i++){
            int h = height[i], pre = premax[i], suf = sufmax[i];
            res += Math.min(pre, suf) - h;
        }
        return res;
    } 
}

单调栈做法

class Solution {
    public int trap(int[] height) {
        Stack<Integer> stack = new Stack<>();
        int res = 0;
        for(int i = 0; i < height.length; i++){
            int right = height[i];
            while(!stack.isEmpty() && height[stack.peek()] < right){
                int bottomidx = stack.pop();
                while(!stack.isEmpty() && height[bottomidx] == height[stack.peek()]){
                    stack.pop();
                }
                if(!stack.isEmpty()){
                    res += (Math.min(height[stack.peek()], height[i]) - height[bottomidx]) * (i-stack.peek()-1);
                }
            }
            stack.push(i);
        }
        return res;
    }
}

es += Math.min(pre, suf) - h;
}
return res;
}
}

单调栈做法

```java
class Solution {
    public int trap(int[] height) {
        Stack<Integer> stack = new Stack<>();
        int res = 0;
        for(int i = 0; i < height.length; i++){
            int right = height[i];
            while(!stack.isEmpty() && height[stack.peek()] < right){
                int bottomidx = stack.pop();
                while(!stack.isEmpty() && height[bottomidx] == height[stack.peek()]){
                    stack.pop();
                }
                if(!stack.isEmpty()){
                    res += (Math.min(height[stack.peek()], height[i]) - height[bottomidx]) * (i-stack.peek()-1);
                }
            }
            stack.push(i);
        }
        return res;
    }
}