904-1031-1156-1208-1223-1233-1234-1343-1546 (9)

Author: gdut-yy

leetcode-01/src/main/java/Solution3.java

@@ -3,25 +3,26 @@
 
 public class Solution3 {
     public int lengthOfLongestSubstring(String s) {
-        Map<Character, Integer> sCntMap = new HashMap<>();
-        int ans = 0;
-        // 双指针-滑动窗口
-        int left = 0;
-        int right = 0;
-        while (right < s.length()) {
-            // 右指针右移
-            char addCh = s.charAt(right);
-            sCntMap.put(addCh, sCntMap.getOrDefault(addCh, 0) + 1);
-            right++;
-            // 左指针右移
-            while (sCntMap.getOrDefault(addCh, 0) > 1) {
-                char rmCh = s.charAt(left);
-                sCntMap.put(rmCh, sCntMap.getOrDefault(rmCh, 0) - 1);
-                left++;
+        int n = s.length();
+        char[] chars = s.toCharArray();
+        Map<Character, Integer> cntMap = new HashMap<>();
+        int l = 0, r = 0;
+        int max = 0;
+        while (r < n) {
+            cntMap.put(chars[r], cntMap.getOrDefault(chars[r], 0) + 1);
+            while (cntMap.get(chars[r]) > 1) {
+                int cnt = cntMap.get(chars[l]);
+                if (cnt == 1) {
+                    cntMap.remove(chars[l]);
+                } else {
+                    cntMap.put(chars[l], cnt - 1);
+                }
+                l++;
             }
-            ans = Math.max(ans, right - left);
+            max = Math.max(max, r - l + 1);
+            r++;
         }
-        return ans;
+        return max;
     }
 }
 /*

leetcode-01/src/main/java/Solution76.java

@@ -16,27 +16,26 @@ public String minWindow(String s, String t) {
         }
 
         Map<Character, Integer> sMap = new HashMap<>();
-        int left = 0, right = 0;
+        int l = 0, r = 0;
         int ansLen = n + 1;
         int ansL = 0;
-        while (right < n) {
-            char ch = s.charAt(right);
+        while (r < n) {
+            char ch = s.charAt(r);
             sMap.put(ch, sMap.getOrDefault(ch, 0) + 1);
             while (check(sMap)) {
-                if (ansLen > right - left + 1) {
-                    ansLen = right - left + 1;
-                    ansL = left;
+                if (ansLen > r - l + 1) {
+                    ansLen = r - l + 1;
+                    ansL = l;
                 }
-                char rm = s.charAt(left);
+                char rm = s.charAt(l);
                 sMap.put(rm, sMap.get(rm) - 1);
-                left++;
+                l++;
             }
-            right++;
+            r++;
         }
         return (ansLen == n + 1) ? "" : s.substring(ansL, ansL + ansLen);
     }
 
-    // sMap 是否完全覆盖 tMap
     private boolean check(Map<Character, Integer> sMap) {
         for (Map.Entry<Character, Integer> entry : tMap.entrySet()) {
             char ch = entry.getKey();

leetcode-10/src/main/java/Solution904.java

@@ -0,0 +1,42 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution904 {
+    public int totalFruit(int[] fruits) {
+        int n = fruits.length;
+        Map<Integer, Integer> cntMap = new HashMap<>();
+        int l = 0, r = 0;
+        int max = 0;
+        while (r < n) {
+            cntMap.put(fruits[r], cntMap.getOrDefault(fruits[r], 0) + 1);
+            while (cntMap.size() > 2) {
+                int cnt = cntMap.get(fruits[l]);
+                if (cnt == 1) {
+                    cntMap.remove(fruits[l]);
+                } else {
+                    cntMap.put(fruits[l], cnt - 1);
+                }
+                l++;
+            }
+            max = Math.max(max, r - l + 1);
+            r++;
+        }
+        return max;
+    }
+}
+/*
+904. 水果成篮
+https://leetcode.cn/problems/fruit-into-baskets/
+
+你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
+你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：
+- 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
+- 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
+- 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
+给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
+提示：
+1 <= fruits.length <= 10^5
+0 <= fruits[i] < fruits.length
+
+双指针 滑动窗口
+ */

leetcode-10/src/test/java/Solution904Tests.java

@@ -0,0 +1,34 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution904Tests {
+    private final Solution904 solution904 = new Solution904();
+
+    @Test
+    public void example1() {
+        int[] fruits = {1, 2, 1};
+        int expected = 3;
+        Assertions.assertEquals(expected, solution904.totalFruit(fruits));
+    }
+
+    @Test
+    public void example2() {
+        int[] fruits = {0, 1, 2, 2};
+        int expected = 3;
+        Assertions.assertEquals(expected, solution904.totalFruit(fruits));
+    }
+
+    @Test
+    public void example3() {
+        int[] fruits = {1, 2, 3, 2, 2};
+        int expected = 4;
+        Assertions.assertEquals(expected, solution904.totalFruit(fruits));
+    }
+
+    @Test
+    public void example4() {
+        int[] fruits = {3, 3, 3, 1, 2, 1, 1, 2, 3, 3, 4};
+        int expected = 5;
+        Assertions.assertEquals(expected, solution904.totalFruit(fruits));
+    }
+}

leetcode-11/src/main/java/Solution1014.java

@@ -1,12 +1,14 @@
 public class Solution1014 {
     public int maxScoreSightseeingPair(int[] values) {
-        int maxI = 0;
-        int maxIj = 0;
-        for (int j = 1; j < values.length; j++) {
-            maxI = Math.max(maxI, values[j - 1] + j - 1);
-            maxIj = Math.max(maxIj, maxI + values[j] - j);
+        int n = values.length;
+        // f[i] 表示 [0, i) 的 (values[i] + i) 最大值
+        int[] f = new int[n + 1];
+        int max = 0;
+        for (int i = 0; i < n; i++) {
+            max = Math.max(max, f[i] + values[i] - i);
+            f[i + 1] = Math.max(f[i], values[i] + i);
         }
-        return maxIj;
+        return max;
     }
 }
 /*
@@ -22,6 +24,7 @@ public int maxScoreSightseeingPair(int[] values) {
 2 <= values.length <= 5 * 10^4
 1 <= values[i] <= 1000
 
+双指针 动态规划
 由于 用例 数值较大，需要将时间复杂度由 O(n^2) 优化到 O(n)
 当 i < j 时：
 f(i,j) = values[i] + values[j] + i - j == (values[i] + i) + (values[j] - j)

leetcode-11/src/main/java/Solution1031.java

@@ -0,0 +1,46 @@
+public class Solution1031 {
+    public int maxSumTwoNoOverlap(int[] nums, int firstLen, int secondLen) {
+        return Math.max(dp(nums, firstLen, secondLen), dp(nums, secondLen, firstLen));
+    }
+
+    private int dp(int[] nums, int firstLen, int secondLen) {
+        int n = nums.length;
+        // f[i] 表示 [0, i) 之间长为 firstLen 的最大和
+        int[] f = new int[n + 1];
+        int l = 0, r = 0, sum = 0, max = 0;
+        while (r < n) {
+            sum += nums[r];
+            while (r - l + 1 > firstLen) sum -= nums[l++];
+            max = Math.max(max, sum);
+            f[r + 1] = Math.max(f[r], max);
+            r++;
+        }
+        r = l = sum = max = 0;
+        while (r < n) {
+            sum += nums[r];
+            while (r - l + 1 > secondLen) sum -= nums[l++];
+            max = Math.max(max, sum + f[l]);
+            r++;
+        }
+        return max;
+    }
+}
+/*
+1031. 两个非重叠子数组的最大和
+https://leetcode.cn/problems/maximum-sum-of-two-non-overlapping-subarrays/
+
+给出非负整数数组 A ，返回两个非重叠（连续）子数组中元素的最大和，子数组的长度分别为 L 和 M。（这里需要澄清的是，长为 L 的子数组可以出现在长为 M 的子数组之前或之后。）
+从形式上看，返回最大的 V，而 V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1]) 并满足下列条件之一：
+0 <= i < i + L - 1 < j < j + M - 1 < A.length, 或
+0 <= j < j + M - 1 < i < i + L - 1 < A.length.
+提示：
+L >= 1
+M >= 1
+L + M <= A.length <= 1000
+0 <= A[i] <= 1000
+
+双指针 滑动窗口 动态规划
+L + M
+M + L
+各判断一次
+ */

leetcode-11/src/test/java/Solution1031Tests.java

@@ -0,0 +1,33 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1031Tests {
+    private final Solution1031 solution1031 = new Solution1031();
+
+    @Test
+    public void example1() {
+        int[] nums = {0, 6, 5, 2, 2, 5, 1, 9, 4};
+        int firstLen = 1;
+        int secondLen = 2;
+        int expected = 20;
+        Assertions.assertEquals(expected, solution1031.maxSumTwoNoOverlap(nums, firstLen, secondLen));
+    }
+
+    @Test
+    public void example2() {
+        int[] nums = {3, 8, 1, 3, 2, 1, 8, 9, 0};
+        int firstLen = 3;
+        int secondLen = 2;
+        int expected = 29;
+        Assertions.assertEquals(expected, solution1031.maxSumTwoNoOverlap(nums, firstLen, secondLen));
+    }
+
+    @Test
+    public void example3() {
+        int[] nums = {2, 1, 5, 6, 0, 9, 5, 0, 3, 8};
+        int firstLen = 4;
+        int secondLen = 3;
+        int expected = 31;
+        Assertions.assertEquals(expected, solution1031.maxSumTwoNoOverlap(nums, firstLen, secondLen));
+    }
+}

leetcode-12/src/main/java/Solution1156.java

@@ -0,0 +1,41 @@
+public class Solution1156 {
+    public int maxRepOpt1(String text) {
+        int n = text.length();
+        char[] s = text.toCharArray();
+
+        int[] cntArr = new int[26];
+        for (char ch : s) {
+            cntArr[ch - 'a']++;
+        }
+
+        int ans = 0;
+        for (char ch = 'a'; ch <= 'z'; ch++) {
+            // 双指针，交换次数
+            int l = 0, r = 0, time = 0;
+            while (r < n) {
+                if (s[r] != ch) time++;
+                while (time > 1) {
+                    if (s[l] != ch) time--;
+                    l++;
+                }
+                if (cntArr[ch - 'a'] >= r - l + 1) {
+                    ans = Math.max(ans, r - l + 1);
+                }
+                r++;
+            }
+        }
+        return ans;
+    }
+}
+/*
+1156. 单字符重复子串的最大长度
+https://leetcode.cn/problems/swap-for-longest-repeated-character-substring/
+
+如果字符串中的所有字符都相同，那么这个字符串是单字符重复的字符串。
+给你一个字符串 text，你只能交换其中两个字符一次或者什么都不做，然后得到一些单字符重复的子串。返回其中最长的子串的长度。
+提示：
+1 <= text.length <= 20000
+text 仅由小写英文字母组成。
+
+双指针 滑动窗口
+ */

leetcode-12/src/test/java/Solution1156Tests.java

@@ -0,0 +1,41 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1156Tests {
+    private final Solution1156 solution1156 = new Solution1156();
+
+    @Test
+    public void example1() {
+        String text = "ababa";
+        int expected = 3;
+        Assertions.assertEquals(expected, solution1156.maxRepOpt1(text));
+    }
+
+    @Test
+    public void example2() {
+        String text = "aaabaaa";
+        int expected = 6;
+        Assertions.assertEquals(expected, solution1156.maxRepOpt1(text));
+    }
+
+    @Test
+    public void example3() {
+        String text = "aaabbaaa";
+        int expected = 4;
+        Assertions.assertEquals(expected, solution1156.maxRepOpt1(text));
+    }
+
+    @Test
+    public void example4() {
+        String text = "aaaaa";
+        int expected = 5;
+        Assertions.assertEquals(expected, solution1156.maxRepOpt1(text));
+    }
+
+    @Test
+    public void example5() {
+        String text = "abcdef";
+        int expected = 1;
+        Assertions.assertEquals(expected, solution1156.maxRepOpt1(text));
+    }
+}

leetcode-13/src/main/java/Solution1208.java

@@ -0,0 +1,38 @@
+public class Solution1208 {
+    public int equalSubstring(String s, String t, int maxCost) {
+        int n = s.length();
+        int l = 0, r = 0;
+        int sum = 0;
+        int max = 0;
+        while (r < n) {
+            sum += f(s, t, r);
+            while (sum > maxCost) {
+                sum -= f(s, t, l);
+                l++;
+            }
+            max = Math.max(max, r - l + 1);
+            r++;
+        }
+        return max;
+    }
+
+    private int f(String s, String t, int i) {
+        return Math.abs(s.charAt(i) - t.charAt(i));
+    }
+}
+/*
+1208. 尽可能使字符串相等
+https://leetcode.cn/problems/get-equal-substrings-within-budget/
+
+给你两个长度相同的字符串，s 和 t。
+将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。
+用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。
+如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。
+如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。
+提示：
+1 <= s.length, t.length <= 10^5
+0 <= maxCost <= 10^6
+s 和 t 都只含小写英文字母。
+
+双指针 滑动窗口
+ */