Java实现LeetCode第201场周赛(题号5483,5484,5471,5486)

有什么不对的地方欢迎大家评论指出

5483. 整理字符串(遍历)
5484. 找出第 N 个二进制字符串中的第 K 位(二分)
5471. 和为目标值的最大数目不重叠非空子数组数目(滑动窗口,前缀和)
5486. 切棍子的最小成本(状压DP)

5483. 整理字符串

给你一个由大小写英文字母组成的字符串 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 <= 100
s 只包含小写和大写英文字母

 /*
        这个题直接暴力便利就可以
        找个list保存一下String的子字符串
        然后便利下一个的时候注意一下,是不是上一个对应的大写,或者小写
        如果是就删除上一个,跳过这次循环,如果不是就加上这个字符
        最后转成String
    
    */
class Solution {
    public String makeGood(String s) {
 ArrayList<Character> list = new ArrayList<>();
        for (char c : s.toCharArray()) {
            //先判断list是不是空的,如果是小写的,并且当前是对应大写的就进来,如果是大写的,并且对应是小写的也进来
             if(list.size()!=0&&((list.get(list.size()-1)>='a' && c==(list.get(list.size()-1)-32) || (list.get(list.size()-1)<='Z' && c==(list.get(list.size()-1)+32))))){
                //删除上一个,这一个也不加上,==抵消了
                list.remove(list.size()-1);
                continue;
            }
            list.add(c);
        }
        //凑成String
        StringBuilder sb = new StringBuilder();
        for (char c : list){
            sb.append(c);
        }
        return sb.toString();
    }
}

5484. 找出第 N 个二进制字符串中的第 K 位

给你两个正整数 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 <= 20
1 <= k <= 2n - 1

class Solution {
     public char findKthBit(int n, int k) {
        int size = (int) Math.pow(2, n);
        //二分法,2的n次方就是二分n次
        //n--是先判断后运算,也就是--n>1,这时范围只有1,2了
        while(n-- > 2) {
            //可以发现每一层的中间那个一定为1
            if(k == size / 2) return '1';
            if(k > size / 2) {
                k -= size / 2;
                //这里指的是该层3/4位置,1/4和3/4恰恰相反,1/4一定位1,因为一半是1,一半的一半也是1
                if(k == size / 4) return '0';
            }
            //二分
            size /= 2;
        }
        return k == 1 ? '0' : '1';
    }
 
}

5471. 和为目标值的最大数目不重叠非空子数组数目

给你一个数组 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^4
0 <= target <= 10^6

class Solution {
    /*
        滑动窗口
        使用map记录前缀和做滑动窗口
    */
    private int[] Sum; 
    public int maxNonOverlapping(int[] nums, int target) {
        Sum =new int[nums.length];
        int sum =0;
        int pre =-1;
        int res =0;
        HashMap<Integer,Integer> map =new HashMap<>();
        map.put(0,-1);
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
            //这个滑动窗口判断的时候一定要注意大于等于pre,否则中间会有重复的
            if(map.get(sum-target)!=null && map.get(sum-target)>=pre){
                res++;
                //这一次符合条件的位置
                pre = i;
            }
            //然后把本次的数量放进去
            map.put(sum,i);
        }
        return res;
    }
}

5486. 切棍子的最小成本

有一根长度为 n 个单位的木棍,棍上从 0 到 n 标记了若干位置。例如,长度为 6 的棍子可以标记如下:
在这里插入图片描述

给你一个整数数组 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 数组中的所有整数都 互不相同

class Solution {
    /*
        这个题和一些合并石子的题目很像
        三层循环,
        	第一层为长度,
        	第二层为起始点,
        	第三层为起始点加当前长度这一段距离最小花费
    
    */
    public int minCost(int n, int[] cuts) {

        int ans = 0;
        int m = cuts.length;
        int[][] dp = new int[m + 1][m + 1];
        int[] arr = new int[m];
        int[] sum = new int[m + 1];
        //把待切割点排序
        Arrays.sort(cuts);

        sum[0] = arr[0] = cuts[0];
        for (int i = 1; i < m; i++) {
            //代表这两个切点之间的距离
            arr[i] = cuts[i] - cuts[i - 1];
            //当前切点的前缀和
            sum[i] = sum[i - 1] + arr[i];
        }

        sum[m] = sum[m - 1] +n - cuts[m - 1];
        m++;
        //都默认给最大值
        for (int i = 0; i < m; i++)
            for (int j = 0; j < m; j++)
                dp[i][j] = 100000000;

        for (int i = 0; i < m; i++)
            dp[i][i] = 0;
        //len为本次切割的长度
        for (int len = 1; len <= m; len++)
            //i为起始点
            for (int i = 0; i + len - 1 < m; i++) {
                //j是以i为起始点长度为len的这一块木板
                int j = i + len - 1;
                //val为前缀和
                int val = sum[j];
                //如果不是第一个点的话,就要减去i-1那个点,才能使这一段的距离
                if (i > 0) val -= sum[i - 1];
                for (int k = i; k < j; k++) {
                    //dp[i][j]第i个切点到第j个切点的最小花费为(以前保存的或者,从i到k和从k+1到j这两块的花费再加上当前的花费))
                    dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j] + val);
                    //System.out.println(i + " " + j + " " + dp[i][j]);
                }
            }

        return dp[0][m - 1];

    } 
}
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页