directory
0.0.0-20240920062246-d0657495930a
Repository: https://github.com/yigmmk/leetcode.git
Documentation: pkg.go.dev
# Packages
* @lc app=leetcode.cn id=1234 lang=golang
*
* [1234] 替换子串得到平衡字符串
*
* https://leetcode.cn/problems/replace-the-substring-for-balanced-string/description/
*
* algorithms
* Medium (36.07%)
* Likes: 131
* Dislikes: 0
* Total Accepted: 11.8K
* Total Submissions: 30.2K
* Testcase Example: '"QWER"'
*
* 有一个只含有 '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' 四种字符
*
*
*/.
* @lc app=leetcode.cn id=1477 lang=golang
*
* [1477] 找两个和为目标值且不重叠的子数组
*
* https://leetcode.cn/problems/find-two-non-overlapping-sub-arrays-each-with-target-sum/description/
*
* algorithms
* Medium (30.78%)
* Likes: 124
* Dislikes: 0
* Total Accepted: 8.3K
* Total Submissions: 26.8K
* Testcase Example: '[3,2,2,4,3]\n3'
*
* 给你一个整数数组 arr 和一个整数值 target 。
*
* 请你在 arr 中找 两个互不重叠的子数组 且它们的和都等于 target 。可能会有多种方案，请你返回满足要求的两个子数组长度和的 最小值 。
*
* 请返回满足要求的最小长度和，如果无法找到这样的两个子数组，请返回 -1 。
*
*
*
* 示例 1：
*
* 输入：arr = [3,2,2,4,3], target = 3
* 输出：2
* 解释：只有两个子数组和为 3 （[3] 和 [3]）。它们的长度和为 2 。
*
*
* 示例 2：
*
* 输入：arr = [7,3,4,7], target = 7
* 输出：2
* 解释：尽管我们有 3 个互不重叠的子数组和为 7 （[7], [3,4] 和 [7]），但我们会选择第一个和第三个子数组，因为它们的长度和 2
* 是最小值。
*
*
* 示例 3：
*
* 输入：arr = [4,3,2,6,2,3,4], target = 6
* 输出：-1
* 解释：我们只有一个和为 6 的子数组。
*
*
* 示例 4：
*
* 输入：arr = [5,5,4,4,5], target = 3
* 输出：-1
* 解释：我们无法找到和为 3 的子数组。
*
*
* 示例 5：
*
* 输入：arr = [3,1,1,1,5,1,2,1], target = 3
* 输出：3
* 解释：注意子数组 [1,2] 和 [2,1] 不能成为一个方案因为它们重叠了。
*
*
*
*
* 提示：
*
*
* 1 <= arr.length <= 10^5
* 1 <= arr[i] <= 1000
* 1 <= target <= 10^8
*
*
*/.
* @lc app=leetcode.cn id=187 lang=golang
*
* [187] 重复的DNA序列
*
* https://leetcode.cn/problems/repeated-dna-sequences/description/
*
* algorithms
* Medium (53.18%)
* Likes: 459
* Dislikes: 0
* Total Accepted: 128.2K
* Total Submissions: 240.9K
* Testcase Example: '"AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"'
*
* DNA序列 由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。
*
*
* 例如，"ACGAATTCCG" 是一个 DNA序列 。
*
*
* 在研究 DNA 时，识别 DNA 中的重复序列非常有用。
*
* 给定一个表示 DNA序列 的字符串 s ，返回所有在 DNA 分子中出现不止一次的 长度为 10 的序列(子字符串)。你可以按 任意顺序
* 返回答案。
*
*
*
* 示例 1：
*
*
* 输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
* 输出：["AAAAACCCCC","CCCCCAAAAA"]
*
*
* 示例 2：
*
*
* 输入：s = "AAAAAAAAAAAAA"
* 输出：["AAAAAAAAAA"]
*
*
*
*
* 提示：
*
*
* 0 <= s.length <= 10^5
* s[i]=='A'、'C'、'G' or 'T'
*
*
*/.
* @lc app=leetcode.cn id=2395 lang=golang
*
* [2395] 和相等的子数组
*
* https://leetcode.cn/problems/find-subarrays-with-equal-sum/description/
*
* algorithms
* Easy (71.76%)
* Likes: 7
* Dislikes: 0
* Total Accepted: 7.2K
* Total Submissions: 10.1K
* Testcase Example: '[4,2,4]'
*
* 给你一个下标从 0 开始的整数数组 nums ，判断是否存在 两个 长度为 2 的子数组且它们的 和 相等。注意，这两个子数组起始位置的下标必须 不相同
* 。
*
* 如果这样的子数组存在，请返回 true，否则返回 false 。
*
* 子数组 是一个数组中一段连续非空的元素组成的序列。
*
*
*
* 示例 1：
*
* 输入：nums = [4,2,4]
* 输出：true
* 解释：元素为 [4,2] 和 [2,4] 的子数组有相同的和 6 。
*
*
* 示例 2：
*
* 输入：nums = [1,2,3,4,5]
* 输出：false
* 解释：没有长度为 2 的两个子数组和相等。
*
*
* 示例 3：
*
* 输入：nums = [0,0,0]
* 输出：true
* 解释：子数组 [nums[0],nums[1]] 和 [nums[1],nums[2]] 的和相等，都为 0 。
* 注意即使子数组的元素相同，这两个子数组也视为不相同的子数组，因为它们在原数组中的起始位置不同。
*
*
*
*
* 提示：
*
*
* 2 <= nums.length <= 1000
* -10^9 <= nums[i] <= 10^9
*
*
*/.
* @lc app=leetcode.cn id=2461 lang=golang
*
* [2461] 长度为 K 子数组中的最大和
*
* https://leetcode.cn/problems/maximum-sum-of-distinct-subarrays-with-length-k/description/
*
* algorithms
* Medium (30.13%)
* Likes: 32
* Dislikes: 0
* Total Accepted: 7.4K
* Total Submissions: 24.5K
* Testcase Example: '[1,5,4,2,9,9,9]\n3'
*
* 给你一个整数数组 nums 和一个整数 k 。请你从 nums 中满足下述条件的全部子数组中找出最大子数组和：
*
*
* 子数组的长度是 k，且
* 子数组中的所有元素 各不相同 。
*
*
* 返回满足题面要求的最大子数组和。如果不存在子数组满足这些条件，返回 0 。
*
* 子数组 是数组中一段连续非空的元素序列。
*
*
*
* 示例 1：
*
* 输入：nums = [1,5,4,2,9,9,9], k = 3
* 输出：15
* 解释：nums 中长度为 3 的子数组是：
* - [1,5,4] 满足全部条件，和为 10 。
* - [5,4,2] 满足全部条件，和为 11 。
* - [4,2,9] 满足全部条件，和为 15 。
* - [2,9,9] 不满足全部条件，因为元素 9 出现重复。
* - [9,9,9] 不满足全部条件，因为元素 9 出现重复。
* 因为 15 是满足全部条件的所有子数组中的最大子数组和，所以返回 15 。
*
*
* 示例 2：
*
* 输入：nums = [4,4,4], k = 3
* 输出：0
* 解释：nums 中长度为 3 的子数组是：
* - [4,4,4] 不满足全部条件，因为元素 4 出现重复。
* 因为不存在满足全部条件的子数组，所以返回 0 。
*
*
*
*
* 提示：
*
*
* 1 <= k <= nums.length <= 10^5
* 1 <= nums[i] <= 10^5
*
*
*/.
* @lc app=leetcode.cn id=3 lang=golang
*
* [3] 无重复字符的最长子串
*
* https://leetcode.cn/problems/longest-substring-without-repeating-characters/description/
*
* algorithms
* Medium (38.93%)
* Likes: 7969
* Dislikes: 0
* Total Accepted: 1.9M
* Total Submissions: 4.9M
* Testcase Example: '"abcabcbb"'
*
* 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
*
*
*
* 示例 1:
*
*
* 输入: s = "abcabcbb"
* 输出: 3
* 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
*
*
* 示例 2:
*
*
* 输入: s = "bbbbb"
* 输出: 1
* 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
*
*
* 示例 3:
*
*
* 输入: s = "pwwkew"
* 输出: 3
* 解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
* 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
*
*
*
*
* 提示：
*
*
* 0 <= s.length <= 5 * 10^4
* s 由英文字母、数字、符号和空格组成
*
*
*/.
* @lc app=leetcode.cn id=567 lang=golang
*
* [567] 字符串的排列
*
* https://leetcode.cn/problems/permutation-in-string/description/
*
* algorithms
* Medium (44.40%)
* Likes: 854
* Dislikes: 0
* Total Accepted: 243K
* Total Submissions: 547.2K
* Testcase Example: '"ab"\n"eidbaooo"'
*
* 给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。
*
* 换句话说，s1 的排列之一是 s2 的 子串 。
*
*
*
* 示例 1：
*
*
* 输入：s1 = "ab" s2 = "eidbaooo"
* 输出：true
* 解释：s2 包含 s1 的排列之一 ("ba").