Merge remote-tracking branch 'origin/master'

2022-03-31 13:40:45 +08:00 · 2022-03-31 13:40:45 +08:00 · 21ab5450db
commit 21ab5450db
parent 82099f4c9e 4c42057410
7 changed files with 435 additions and 0 deletions
--- a/src/main/java/contest/y2022/m3/week/Solution286.java
+++ b/src/main/java/contest/y2022/m3/week/Solution286.java
@ -0,0 +1,95 @@
+package contest.y2022.m3.week;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @description:
+ * @author: Administrator
+ * @date: 2021/8/22-10:29
+ */
+public class Solution286 {
+    public static void main(String[] args) {
+        Solution286 solution = new Solution286();
+//        int[] arrs = new int[40000];
+//        Arrays.fill(arrs, 100000);
+//        solution.minDeletion(arrs);
+//        System.out.println(solution.minDeletion(new int[]{0,1,5,4,2,4,7,2,3,0,3,0,0,9,7,5,9,4,3,9,9,2,1,6,3,1,0,7,6,6,6,0,1,7,1,9,4,9,3,3,4,5,0,3,8,7,1,8,4,5}));
+        long[] arrs=solution.kthPalindrome(new int[]{1,2,3,4,5,90},3);
+        for (int i = 0; i < arrs.length; i++) {
+            System.out.println(arrs[i]);
+        }
+    }
+
+    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
+        List<Integer> list1 = Arrays.stream(nums1).boxed().collect(Collectors.toList());
+        List<Integer> list2 = Arrays.stream(nums2).boxed().collect(Collectors.toList());
+        List<List<Integer>> list = new ArrayList<>();
+        list.add(new ArrayList<>());
+        list.add(new ArrayList<>());
+        for (int num : list1) {
+            if (!list2.contains(num) && !list.get(0).contains(num)) {
+                list.get(0).add(num);
+            }
+        }
+        for (int num : list2) {
+            if (!list1.contains(num) && !list.get(1).contains(num)) {
+                list.get(1).add(num);
+            }
+        }
+        return list;
+    }
+
+    public int minDeletion(int[] nums) {
+        if (nums.length < 2) {
+            return nums.length;
+        }
+        List<Integer> list = new ArrayList<>();
+        list.add(nums[0]);
+        list.add(nums[1]);
+        int index = 2;
+        for (int i = 2; i < nums.length; i++) {
+            if (nums[i] != list.get(index - 1) || nums[i] != list.get(index - 2)) {
+                list.add(0, nums[i]);
+                index++;
+            }
+        }
+        if (list.size() < 2) {
+            return nums.length;
+        }
+        for (int i = 0; i < list.size(); i++) {
+            if (i % 2 == 0 && i + 1 < list.size() && list.get(i).equals(list.get(i + 1))) {
+                list.remove(i);
+            }
+        }
+        int sub = list.size() % 2 == 0 ? list.size() : list.size() - 1;
+        return nums.length - sub;
+    }
+
+    public long[] kthPalindrome(int[] queries, int intLength) {
+        long x = 10 * ((intLength + 1) / 2 - 1);
+        long[] arrs = new long[queries.length];
+        int index = 0;
+        for (int query : queries) {
+            long tmp = x + query - 1;
+            StringBuilder sb = new StringBuilder();
+            sb.append(tmp);
+            String str;
+            if (intLength % 2 == 0) {
+                str = sb.toString() + sb.reverse();
+            } else {
+                str = sb + sb.reverse().substring(1);
+            }
+            if (str.length() != intLength) {
+                arrs[index] = -1;
+            } else {
+                arrs[index] = Long.parseLong(str);
+            }
+            index++;
+        }
+        return arrs;
+    }
+}
--- a/src/main/java/leetcode/editor/cn/ContiguousSequenceLcci.java
+++ b/src/main/java/leetcode/editor/cn/ContiguousSequenceLcci.java
@ -0,0 +1,44 @@
+//给定一个整数数组，找出总和最大的连续数列，并返回总和。 
+//
+// 示例： 
+//
+// 输入： [-2,1,-3,4,-1,2,1,-5,4]
+//输出： 6
+//解释： 连续子数组 [4,-1,2,1] 的和最大，为 6。
+// 
+//
+// 进阶： 
+//
+// 如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。 
+// Related Topics 数组 分治 动态规划 👍 109 👎 0
+
+package leetcode.editor.cn;
+
+//面试题 16.17:连续数列
+public class ContiguousSequenceLcci {
+    public static void main(String[] args) {
+        Solution solution = new ContiguousSequenceLcci().new Solution();
+
+    }
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int maxSubArray(int[] nums) {
+            int b = nums[0];
+            int sum = b;
+            for (int i = 1; i < nums.length; i++) {
+                if (b < 0) {
+                    b = nums[i];
+                } else {
+                    b += nums[i];
+                }
+                if (b > sum) {
+                    sum = b;
+                }
+            }
+            return sum;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
--- a/src/main/java/leetcode/editor/cn/CreateMaximumNumber.java
+++ b/src/main/java/leetcode/editor/cn/CreateMaximumNumber.java
@ -0,0 +1,105 @@
+//给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接
+//成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。 
+//
+// 求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。 
+//
+// 说明: 请尽可能地优化你算法的时间和空间复杂度。 
+//
+// 示例 1: 
+//
+// 输入:
+//nums1 = [3, 4, 6, 5]
+//nums2 = [9, 1, 2, 5, 8, 3]
+//k = 5
+//输出:
+//[9, 8, 6, 5, 3] 
+//
+// 示例 2: 
+//
+// 输入:
+//nums1 = [6, 7]
+//nums2 = [6, 0, 4]
+//k = 5
+//输出:
+//[6, 7, 6, 0, 4] 
+//
+// 示例 3: 
+//
+// 输入:
+//nums1 = [3, 9]
+//nums2 = [8, 9]
+//k = 3
+//输出:
+//[9, 8, 9] 
+// Related Topics 栈 贪心 单调栈 👍 458 👎 0
+
+package leetcode.editor.cn;
+
+//321:拼接最大数
+public class CreateMaximumNumber {
+    public static void main(String[] args) {
+        Solution solution = new CreateMaximumNumber().new Solution();
+
+    }
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int[] maxNumber(int[] nums1, int[] nums2, int k) {
+            int[] res = new int[0];
+            // 从 nums1 中选出长 i 的子序列
+            for (int i = 0; i <= k && i <= nums1.length; i++) {
+                // 从 nums2 中选出长 k - i 的子序列
+                if (k - i >= 0 && k - i <= nums2.length) {
+                    // 合并
+                    int[] tmp = merge(subMaxNumber(nums1, i), subMaxNumber(nums2, k - i));
+                    // 取最大值
+                    if (compare(tmp, 0, res, 0)) {
+                        res = tmp;
+                    }
+                }
+            }
+            return res;
+        }
+
+        // 类似于单调递减栈
+        public int[] subMaxNumber(int[] nums, int len) {
+            int[] subNums = new int[len];
+            int cur = 0, rem = nums.length - len; // rem 表示还可以删去多少字符
+            for (int i = 0; i < nums.length; i++) {
+                while (cur > 0 && subNums[cur - 1] < nums[i] && rem > 0) {
+                    cur--;
+                    rem--;
+                }
+                if (cur < len) {
+                    subNums[cur++] = nums[i];
+                } else {
+                    rem--; // 避免超过边界而少删字符
+                }
+            }
+            return subNums;
+        }
+
+        public int[] merge(int[] nums1, int[] nums2) {
+            int[] res = new int[nums1.length + nums2.length];
+            int cur = 0, p1 = 0, p2 = 0;
+            while (cur < nums1.length + nums2.length) {
+                if (compare(nums1, p1, nums2, p2)) { // 不能只比较当前值，如果当前值相等还需要比较后续哪个大
+                    res[cur++] = nums1[p1++];
+                } else {
+                    res[cur++] = nums2[p2++];
+                }
+            }
+            return res;
+        }
+
+        public boolean compare(int[] nums1, int p1, int[] nums2, int p2) {
+            if (p2 >= nums2.length) return true;
+            if (p1 >= nums1.length) return false;
+            if (nums1[p1] > nums2[p2]) return true;
+            if (nums1[p1] < nums2[p2]) return false;
+            return compare(nums1, p1 + 1, nums2, p2 + 1);
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
--- a/src/main/java/leetcode/editor/cn/MaximizeTheConfusionOfAnExam.java
+++ b/src/main/java/leetcode/editor/cn/MaximizeTheConfusionOfAnExam.java
@ -0,0 +1,93 @@
+//一位老师正在出一场由 n 道判断题构成的考试，每道题的答案为 true （用 'T' 表示）或者 false （用 'F' 表示）。老师想增加学生对自己做出
+//答案的不确定性，方法是 最大化 有 连续相同 结果的题数。（也就是连续出现 true 或者连续出现 false）。 
+//
+// 给你一个字符串 answerKey ，其中 answerKey[i] 是第 i 个问题的正确结果。除此以外，还给你一个整数 k ，表示你能进行以下操作的最
+//多次数： 
+//
+// 
+// 每次操作中，将问题的正确答案改为 'T' 或者 'F' （也就是将 answerKey[i] 改为 'T' 或者 'F' ）。 
+// 
+//
+// 请你返回在不超过 k 次操作的情况下，最大 连续 'T' 或者 'F' 的数目。 
+//
+// 
+//
+// 示例 1： 
+//
+// 
+//输入：answerKey = "TTFF", k = 2
+//输出：4
+//解释：我们可以将两个 'F' 都变为 'T' ，得到 answerKey = "TTTT" 。
+//总共有四个连续的 'T' 。
+// 
+//
+// 示例 2： 
+//
+// 
+//输入：answerKey = "TFFT", k = 1
+//输出：3
+//解释：我们可以将最前面的 'T' 换成 'F' ，得到 answerKey = "FFFT" 。
+//或者，我们可以将第二个 'T' 换成 'F' ，得到 answerKey = "TFFF" 。
+//两种情况下，都有三个连续的 'F' 。
+// 
+//
+// 示例 3： 
+//
+// 
+//输入：answerKey = "TTFTTFTT", k = 1
+//输出：5
+//解释：我们可以将第一个 'F' 换成 'T' ，得到 answerKey = "TTTTTFTT" 。
+//或者我们可以将第二个 'F' 换成 'T' ，得到 answerKey = "TTFTTTTT" 。
+//两种情况下，都有五个连续的 'T' 。
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// n == answerKey.length 
+// 1 <= n <= 5 * 10⁴ 
+// answerKey[i] 要么是 'T' ，要么是 'F' 
+// 1 <= k <= n 
+// 
+// Related Topics 字符串 二分查找 前缀和 滑动窗口 👍 155 👎 0
+
+package leetcode.editor.cn;
+
+//2024:考试的最大困扰度
+public class MaximizeTheConfusionOfAnExam {
+    public static void main(String[] args) {
+        Solution solution = new MaximizeTheConfusionOfAnExam().new Solution();
+        solution.maxConsecutiveAnswers("TTFF", 2);
+    }
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        String s;
+        int n, k;
+
+        public int maxConsecutiveAnswers(String answerKey, int _k) {
+            s = answerKey;
+            n = s.length();
+            k = _k;
+            return Math.max(getCnt('T'), getCnt('F'));
+        }
+
+        int getCnt(char c) {
+            int ans = 0;
+            for (int i = 0, j = 0, cnt = 0; i < n; i++) {
+                if (s.charAt(i) == c) cnt++;
+                while (cnt > k) {
+                    if (s.charAt(j) == c) cnt--;
+                    j++;
+                }
+                ans = Math.max(ans, i - j + 1);
+            }
+            return ans;
+        }
+    }
+
+//leetcode submit region end(Prohibit modification and deletion)
+
+}
--- a/src/main/java/leetcode/editor/cn/doc/content/ContiguousSequenceLcci.md
+++ b/src/main/java/leetcode/editor/cn/doc/content/ContiguousSequenceLcci.md
@ -0,0 +1,13 @@
+<p>给定一个整数数组，找出总和最大的连续数列，并返回总和。</p>
+
+<p><strong>示例：</strong></p>
+
+<pre><strong>输入：</strong> [-2,1,-3,4,-1,2,1,-5,4]
+<strong>输出：</strong> 6
+<strong>解释：</strong> 连续子数组 [4,-1,2,1] 的和最大，为 6。
+</pre>
+
+<p><strong>进阶：</strong></p>
+
+<p>如果你已经实现复杂度为 O(<em>n</em>) 的解法，尝试使用更为精妙的分治法求解。</p>
+<div><div>Related Topics</div><div><li>数组</li><li>分治</li><li>动态规划</li></div></div><br><div><li>👍 109</li><li>👎 0</li></div>
--- a/src/main/java/leetcode/editor/cn/doc/content/CreateMaximumNumber.md
+++ b/src/main/java/leetcode/editor/cn/doc/content/CreateMaximumNumber.md
@ -0,0 +1,33 @@
+<p>给定长度分别为&nbsp;<code>m</code>&nbsp;和&nbsp;<code>n</code>&nbsp;的两个数组，其元素由&nbsp;<code>0-9</code>&nbsp;构成，表示两个自然数各位上的数字。现在从这两个数组中选出 <code>k (k &lt;= m + n)</code>&nbsp;个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。</p>
+
+<p>求满足该条件的最大数。结果返回一个表示该最大数的长度为&nbsp;<code>k</code>&nbsp;的数组。</p>
+
+<p><strong>说明: </strong>请尽可能地优化你算法的时间和空间复杂度。</p>
+
+<p><strong>示例&nbsp;1:</strong></p>
+
+<pre><strong>输入:</strong>
+nums1 = <code>[3, 4, 6, 5]</code>
+nums2 = <code>[9, 1, 2, 5, 8, 3]</code>
+k = <code>5</code>
+<strong>输出:</strong>
+<code>[9, 8, 6, 5, 3]</code></pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre><strong>输入:</strong>
+nums1 = <code>[6, 7]</code>
+nums2 = <code>[6, 0, 4]</code>
+k = <code>5</code>
+<strong>输出:</strong>
+<code>[6, 7, 6, 0, 4]</code></pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre><strong>输入:</strong>
+nums1 = <code>[3, 9]</code>
+nums2 = <code>[8, 9]</code>
+k = <code>3</code>
+<strong>输出:</strong>
+<code>[9, 8, 9]</code></pre>
+<div><div>Related Topics</div><div><li>栈</li><li>贪心</li><li>单调栈</li></div></div><br><div><li>👍 458</li><li>👎 0</li></div>
--- a/src/main/java/leetcode/editor/cn/doc/content/MaximizeTheConfusionOfAnExam.md
+++ b/src/main/java/leetcode/editor/cn/doc/content/MaximizeTheConfusionOfAnExam.md
@ -0,0 +1,52 @@
+<p>一位老师正在出一场由 <code>n</code>&nbsp;道判断题构成的考试，每道题的答案为 true （用 <code><span style="">'T'</span></code> 表示）或者 false （用 <code>'F'</code>&nbsp;表示）。老师想增加学生对自己做出答案的不确定性，方法是&nbsp;<strong>最大化&nbsp;</strong>有 <strong>连续相同</strong>&nbsp;结果的题数。（也就是连续出现 true 或者连续出现 false）。</p>
+
+<p>给你一个字符串&nbsp;<code>answerKey</code>&nbsp;，其中&nbsp;<code>answerKey[i]</code>&nbsp;是第 <code>i</code>&nbsp;个问题的正确结果。除此以外，还给你一个整数 <code>k</code>&nbsp;，表示你能进行以下操作的最多次数：</p>
+
+<ul>
+	<li>每次操作中，将问题的正确答案改为&nbsp;<code>'T'</code> 或者&nbsp;<code>'F'</code>&nbsp;（也就是将 <code>answerKey[i]</code> 改为&nbsp;<code>'T'</code>&nbsp;或者&nbsp;<code>'F'</code>&nbsp;）。</li>
+</ul>
+
+<p>请你返回在不超过 <code>k</code>&nbsp;次操作的情况下，<strong>最大</strong>&nbsp;连续 <code>'T'</code>&nbsp;或者 <code>'F'</code>&nbsp;的数目。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<b>输入：</b>answerKey = "TTFF", k = 2
+<b>输出：</b>4
+<b>解释：</b>我们可以将两个 'F' 都变为 'T' ，得到 answerKey = "<em><strong>TTTT</strong></em>" 。
+总共有四个连续的 'T' 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<b>输入：</b>answerKey = "TFFT", k = 1
+<b>输出：</b>3
+<b>解释：</b>我们可以将最前面的 'T' 换成 'F' ，得到 answerKey = "<em><strong>FFF</strong></em>T" 。
+或者，我们可以将第二个 'T' 换成 'F' ，得到 answerKey = "T<em><strong>FFF</strong></em>" 。
+两种情况下，都有三个连续的 'F' 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<b>输入：</b>answerKey = "TTFTTFTT", k = 1
+<b>输出：</b>5
+<b>解释：</b>我们可以将第一个 'F' 换成 'T' ，得到 answerKey = "<em><strong>TTTTT</strong></em>FTT" 。
+或者我们可以将第二个 'F' 换成 'T' ，得到 answerKey = "TTF<em><strong>TTTTT</strong></em>" 。
+两种情况下，都有五个连续的 'T' 。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == answerKey.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>answerKey[i]</code>&nbsp;要么是&nbsp;<code>'T'</code> ，要么是&nbsp;<code>'F'</code></li>
+	<li><code>1 &lt;= k &lt;= n</code></li>
+</ul>
+<div><div>Related Topics</div><div><li>字符串</li><li>二分查找</li><li>前缀和</li><li>滑动窗口</li></div></div><br><div><li>👍 155</li><li>👎 0</li></div>