【LeetCode】周赛纪录（十）第201场周赛20200809 整理字符串-模拟/栈 找出第 N 个二进制字符串的第 K 位-递归 和为目标值的不重叠非空子数组数目-前缀和 切棍子最小成本-区间dp
周赛第201场20200809
5483. 整理字符串
题目描述1
给你一个由大小写英文字母组成的字符串 s 。
一个整理好的字符串中，两个相邻字符 s[i] 和 s[i + 1] 不会同时满足下述条件：
0 <= i <= s.length - 2
s[i] 是小写字符，但 s[i + 1] 是相同的大写字符；反之亦然 。
请你将字符串整理好，每次你都可以从字符串中选出满足上述条件的 两个相邻 字符并删除，直到字符串整理好为止。
请返回整理好的 字符串 。题目保证在给出的约束条件下，测试样例对应的答案是唯一的。
注意：空字符串也属于整理好的字符串，尽管其中没有任何字符。
示例 1：
输入：s = "leEeetcode"
输出："leetcode"
解释：无论你第一次选的是 i = 1 还是 i = 2，都会使 "leEeetcode" 缩减为 "leetcode" 。
示例 2：
输入：s = "abBAcC"
输出：""
解释：存在多种不同情况，但所有的情况都会导致相同的结果。例如：
"abBAcC" --> "aAcC" --> "cC" --> ""
"abBAcC" --> "abBA" --> "aA" --> ""
示例 3：
输入：s = "s"
输出："s"
提示：
1 <= s.length <= 100s只包含小写和大写英文字母
Solution1
- 直接模拟，每次不断寻找，直到找不到要删除的字符为止
class Solution {
public String makeGood(String s) {
if(s.length() <= 1) return s;
StringBuilder sb = new StringBuilder(s);
StringBuilder sb2 = new StringBuilder(s);
boolean flag = true;
while(sb.length() != 0){
if(flag == false){//如果上一轮都没有删除的话，说明已经删完了，直接退出返回答案
break;
}
flag = false;//初始化，默认没有删除，后面如果有删除的话，flag置为true
for(int i = 0; i < sb2.length()-1; i++){
char c1 = sb.charAt(i);
char c2 = sb.charAt(i+1);
if(Math.abs(c1 - c2) == 32){
sb.delete(i, i+2);
flag = true;
sb2 = sb;//删除后字符串里的i会变化
}
}
}
return sb.toString();
}
}
- 栈。依次将字符串s的字符入栈，如果当前字符是栈顶字符对应的大小写，则将栈顶元素弹出
class Solution {
public String makeGood(String s) {
if(s.length() <= 1) return s;
Deque<Character> stack = new ArrayDeque<>();
int n = s.length();
for(int i = 0; i < n; i++){
char c1 = s.charAt(i);
if(stack.isEmpty()){
stack.push(c1);
}else{
char c2 = stack.peek();
//如果栈顶元素是c1的大写或者小写，弹出栈顶元素,否则，入栈
if(Math.abs(c1 - c2) == 32){
stack.pop();
}else{
stack.push(c1);
}
}
}
//依次弹出栈顶元素，翻转
StringBuilder sb = new StringBuilder();
while(!stack.isEmpty()){
sb.append(stack.pop());
}
return sb.reverse().toString();
}
}
5484. 找出第 N 个二进制字符串中的第 K 位
题目描述2
给你两个正整数 n 和 k，二进制字符串 Sn 的形成规则如下：
S1 = “0”
当 i > 1 时，Si = Si-1 + “1” + reverse(invert(Si-1))
其中 + 表示串联操作，reverse(x) 返回反转 x 后得到的字符串，而 invert(x) 则会翻转 x 中的每一位（0 变为 1，而 1 变为 0）
例如，符合上述描述的序列的前 4 个字符串依次是：
S1 = “0”
S2 = “011”
S3 = “0111001”
S4 = “011100110110001”
请你返回 Sn 的 第 k 位字符 ，题目数据保证 k 一定在 Sn 长度范围以内。
示例 1：
输入：n = 3, k = 1
输出："0"
解释：S3 为 "0111001"，其第 1 位为 "0" 。
示例 2：
输入：n = 4, k = 11
输出："1"
解释：S4 为 "011100110110001"，其第 11 位为 "1" 。
示例 3：
输入：n = 1, k = 1
输出："0"
示例 4：
输入：n = 2, k = 3
输出："1"
提示：
1 <= n <= 201 <= k <= 2n - 1
Solution2
- 按照规则直接把Sn是什么算出来
class Solution {
public char findKthBit(int n, int k) {
StringBuilder sb = new StringBuilder();
sb.append("0");
for(int i = 1; i <= n-1; i++){
StringBuilder tmp = new StringBuilder(sb);
sb.append("1");
sb.append(reverseAndInvert(tmp));
}
return sb.charAt(k-1);
}
public StringBuilder reverseAndInvert(StringBuilder sb){
StringBuilder r = new StringBuilder();
for(int i = 0; i < sb.length(); i++){
if(sb.charAt(i) == '0'){
r.append('1');
}else{
r.append('0');
}
}
return r.reverse();
}
}
-
递归
先算出S[n-1]的长度len。
- 若k=len+1，说明是中间那个1
- 若k<=len，那么S[n]的第k位也是S[n-1]的第k位
- 若k>len+1，那么S[n]的第k位是S[n-1]中的第（n-k+1）个元素翻转后的结果
class Solution {
public char findKthBit(int n, int k) {
if(n == 1){
return '0';
}
int preLen = (1 <<(n-1)) - 1;
int len = (1 << n) - 1;
if(k == preLen + 1){
return '1';
}else if(k <= preLen){
return findKthBit(n-1, k);
}else{
return (char)(((findKthBit(n-1, len-k+1) - '0') ^ 1) + '0');
}
}
}
5471. 和为目标值的最大数目不重叠非空子数组数目
题目描述3
给你一个数组 nums 和一个整数 target 。
请你返回 非空不重叠 子数组的最大数目，且每个子数组中数字和都为 target 。
示例 1：
输入：nums = [1,1,1,1,1], target = 2
输出：2
解释：总共有 2 个不重叠子数组（加粗数字表示） [1,1,1,1,1] ，它们的和为目标值 2 。
示例 2：
输入：nums = [-1,3,5,1,4,2,-9], target = 6
输出：2
解释：总共有 3 个子数组和为 6 。
([5,1], [4,2], [3,5,1,4,2,-9]) 但只有前 2 个是不重叠的。
示例 3：
输入：nums = [-2,6,6,3,5,4,1,2,8], target = 10
输出：3
示例 4：
输入：nums = [0,0,0], target = 0
输出：3
提示：
1 <= nums.length <= 10^5-10^4 <= nums[i] <= 10^40 <= target <= 10^6
Solution3
前缀和+哈希表 类似560题 和为K的子数组
区别在于这里的数组不能重叠，所以每次符合条件后要置空sum和map
class Solution {
public int maxNonOverlapping(int[] nums, int target) {
//类似：560. 和为K的子数组
// key：前缀和。value：这个前缀和出现的次数 0或1
Map<Integer, Integer> preSumFreq = new HashMap<>();
preSumFreq.put(0, 1);
int sum = 0;//前缀和
int count = 0;
for(int num : nums){
sum += num;
// a[j+1]+...+a[i] = S[i] - S[j]
// S[j] = S[i] - target，要让j越大越好
if (preSumFreq.containsKey(sum - target)){
count++;
//因为不能重叠，所以符合条件后要置空sum和map
sum = 0;
preSumFreq = new HashMap<>();
}
preSumFreq.put(sum, preSumFreq.getOrDefault(sum, 0) + 1);
}
return count;
}
}
5486. 切棍子的最小成本
题目描述4
有一根长度为 n 个单位的木棍，棍上从 0 到 n 标记了若干位置。
给你一个整数数组 cuts ，其中 cuts[i] 表示你需要将棍子切开的位置。
你可以按顺序完成切割，也可以根据需要更改切割的顺序。
每次切割的成本都是当前要切割的棍子的长度，切棍子的总成本是历次切割成本的总和。对棍子进行切割将会把一根木棍分成两根较小的木棍（这两根木棍的长度和就是切割前木棍的长度）。请参阅第一个示例以获得更直观的解释。
返回切棍子的 最小总成本 。
示例 1：
输入：n = 7, cuts = [1,3,4,5]
输出：16
解释：按 [1, 3, 4, 5] 的顺序切割的情况如下所示：
第一次切割长度为 7 的棍子，成本为 7 。第二次切割长度为 6 的棍子（即第一次切割得到的第二根棍子），第三次切割为长度 4 的棍子，最后切割长度为 3 的棍子。总成本为 7 + 6 + 4 + 3 = 20 。
而将切割顺序重新排列为 [3, 5, 1, 4] 后，总成本 = 16（如示例图中 7 + 4 + 3 + 2 = 16）。
示例 2：
输入：n = 9, cuts = [5,6,1,4,2]
输出：22
解释：如果按给定的顺序切割，则总成本为 25 。总成本 <= 25 的切割顺序很多，例如，[4，6，5，2，1] 的总成本 = 22，是所有可能方案中成本最小的。
提示：
2 <= n <= 10^6
1 <= cuts.length <= min(n - 1, 100)
1 <= cuts[i] <= n - 1
cuts 数组中的所有整数都 互不相同
Solution4
区间dp。类似石子合并问题。想象成每次合并相邻的木棍，使得总成本最小。
-
状态
dp[i][j]：- 集合：所有把
[i,j]的木棍合成一根的方案 - 属性：求这些方案的最小成本。最后答案要求的就是
dp[0][n]。
- 集合：所有把
-
状态计算：
最后的合并位置是k
dp[i][j] = min(dp[i, k] + dp[k, j] + cost)
class Solution {
public int minCost(int n, int[] cuts) {
List<Integer> list = new ArrayList<>();
list.add(0);
list.add(n);
for(int num : cuts){
list.add(num);
}
Collections.sort(list);
int m = list.size();
int[][] dp = new int[m][m];
//初始化
for(int i = 0; i < m; i++){
dp[i][i] = 0;
}
for(int len = 2; len < m; len++){//区间
for(int i = 0; i + len < m; i++){//左端点
int j = i + len;//右端点
dp[i][j] = Integer.MAX_VALUE;
// 枚举最后一个分割点
for(int k = i+1; k < j; k++){
dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j] + list.get(j) - list.get(i));
}
}
}
return dp[0][m-1];
}
}
欢迎关注公众号：GitKid，暂时每日分享LeetCode题解，在不断地学习中，公众号内容也在不断充实，欢迎扫码关注
