代码随想录的数组部分，废话不多说直接刷题！！！
leetcode 209 长度最小的子数组
给定一个含有 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
public static int minSubArrayLen(int target, int[] nums) {
if (nums == null || nums.length == 0)
return 0;
int i = 0, j = 0, sum = 0, min = Integer.MAX_VALUE;
while (j < nums.length) {
sum += nums[j++];
while (sum >= target) {
min = Math.min(min, j - i);
sum -= nums[i++];
}
}
return min == Integer.MAX_VALUE ? 0 : min;
}
leetcode 904 水果成蓝
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
示例 1：
输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。
示例 2：
输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。
示例 3：
输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。
示例 4：
输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树
public int totalFruit(int[] tree) {
int ans = 0;
Map<Integer, Integer> count = new HashMap<>();
for (int l = 0, r = 0; r < tree.length; ++r) {
count.put(tree[r], count.getOrDefault(tree[r], 0) + 1);
while (count.size() > 2) {
count.put(tree[l], count.get(tree[l]) - 1);
count.remove(tree[l], 0);
++l;
}
ans = Math.max(ans, r - l + 1);
}
return ans;
}
leetcode76 最小覆盖子串
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
示例 1：
输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。
示例 2：
输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。
示例 3：
输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。
示例 4：
输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树
public String minWindow(String s, String t) {
if (s == null || t == null || s.length() == 0 || t.length() == 0 ||
s.length() < t.length()) {
return new String();
}
int[] map = new int[128];
int count = t.length();
int start = 0, end = 0, minLen = Integer.MAX_VALUE, startIndex = 0;
/// UPVOTE !
for (char c : t.toCharArray()) {
map[c]++;
}
char[] chS = s.toCharArray();
while (end < chS.length) {
if (map[chS[end++]]-- > 0) {
count--;
}
while (count == 0) {
if (end - start < minLen) {
startIndex = start;
minLen = end - start;
}
if (map[chS[start++]]++ == 0) {
count++;
}
}
}
return minLen == Integer.MAX_VALUE ? new String() :
new String(chS, startIndex, minLen);
}
2、
class Solution {
public String minWindow(String s, String t) {
//维护s串中滑动窗口中各个字符出现次数
Map<Character, Integer> hs = new HashMap<>();
//维护t串中各个字符出现次数
Map<Character, Integer> ht = new HashMap<>();
for (int i = 0; i < t.length(); i++) {
ht.put(t.charAt(i), ht.getOrDefault(t.charAt(i), 0)+1);
}
String ans="";
//cnt维护s串[left,right]中满足t串的元素的个数，记录相对应字符的总数
int len=Integer.MAX_VALUE,cnt=0;
//区间[left,right]表示当前滑动窗口
for (int left=0,right = 0; right < s.length(); right++) {
hs.put(s.charAt(right), hs.getOrDefault(s.charAt(right), 0)+1);
//如果ht表中也包含当前字符
if (ht.containsKey(s.charAt(right))) {
//并且hs表中的字符个数<=ht表中的字符个数,说明该字符是必须的，并且还未到达字符串t所要求的数量
if (hs.get(s.charAt(right))<=ht.get(s.charAt(right))) {
cnt++;
}
}
//收缩滑动窗口
//如果左边界的值不在ht表中 或者 它在hs表中的出现次数多于ht表中的出现次数
while(left < right && (!ht.containsKey(s.charAt(left)) || hs.get(s.charAt(left)) > ht.get(s.charAt(left)))){
hs.put(s.charAt(left),hs.get(s.charAt(left)) - 1);
left++;
}
//此时滑动窗口包含符串 t 的全部字符
if (cnt==t.length()&&right-left+1<len) {
len=right-left+1;
ans=s.substring(left,right+1);
}
}
return ans;
}
}