Java实现LeetCode第31场双周赛(题号5456-5459)

别人看到题都是,这个题怎么怎么解决,
我看到题……这个题怎么改改可以换成另一道题
嘿嘿嘿
双周赛链接

5456. 在区间范围内统计奇数数目

给你两个非负整数 low 和 high 。请你返回 low 和 high 之间(包括二者)奇数的数目。

示例 1:

输入:low = 3, high = 7
输出:3
解释:37 之间奇数数字为 [3,5,7] 。
示例 2:

输入:low = 8, high = 10
输出:1
解释:810 之间奇数数字为 [9]

提示:

0 <= low <= high <= 10^9
class Solution {
    /*
        因为是奇偶数挨着的,所以如果不包含两个的话,直接相减/2就可以了
        但这里是包含的,如果两边都是奇数就会多加了一个
        所以如果第一个是奇数就++,第二个是奇数,就在判断一下第一个是不是奇数,如果不是就++
    */
    public int countOdds(int low, int high) {
          int temp = (high-low)/2;
        if((low &1)==1) ++temp;
        if((high &1)==1 && (low &1)==0){ 
                ++temp; 
        }
        return temp;
    }
}

5457. 和为奇数的子数组数目

给你一个整数数组 arr 。请你返回和为 奇数 的子数组数目。

由于答案可能会很大,请你将结果对 10^9 + 7 取余后返回。

示例 1:

输入:arr = [1,3,5]
输出:4
解释:所有的子数组为 [[1],[1,3],[1,3,5],[3],[3,5],[5]] 。
所有子数组的和为 [1,4,9,3,8,5].
奇数和包括 [1,9,3,5] ,所以答案为 4 。
示例 2 :

输入:arr = [2,4,6]
输出:0
解释:所有子数组为 [[2],[2,4],[2,4,6],[4],[4,6],[6]] 。
所有子数组和为 [2,6,12,4,10,6] 。
所有子数组和都是偶数,所以答案为 0 。
示例 3:

输入:arr = [1,2,3,4,5,6,7]
输出:16
示例 4:

输入:arr = [100,100,99,99]
输出:4
示例 5:

输入:arr = [7]
输出:1
 

提示:

1 <= arr.length <= 10^5
1 <= arr[i] <= 100
class Solution {
    /*
        这里我们需要先知道一点点前缀和的意思
            如果当前的和为1,那么找到前缀和为0的,在这一段中,和就为奇数
            因为前缀和为0的变成前缀和为1的,中间的和肯定是一个奇数
            同理,如果当前的和为0,那么找到前缀和为1的,在这一段中,和就为奇数
            我们只需要统计前缀和为0和1的个数即可
    */
     public int numOfSubarrays(int[] arr) {
        int[] cnts = new int[2];
        int cur = 0;
        int ans = 0;
        cnts[0] = 1;
        int mod = 1000000007;
        for(int x : arr){
            //查看当前的前缀和
            cur = (cur + x) % 2;
            //结果加上前缀和相反的个数
            ans += cnts[1 - cur];
            //前缀和为cur的个数++
            cnts[cur]++;
            ans %= mod;
        }
        return  ans % mod;
    }
}

5458. 字符串的好分割数目

给你一个字符串 s ,一个分割被称为 「好分割」 当它满足:将 s 分割成 2 个字符串 p 和 q ,它们连接起来等于 s 且 p 和 q 中不同字符的数目相同。

请你返回 s 中好分割的数目。

示例 1:

输入:s = "aacaba"
输出:2
解释:总共有 5 种分割字符串 "aacaba" 的方法,其中 2 种是好分割。
("a", "acaba") 左边字符串和右边字符串分别包含 1 个和 3 个不同的字符。
("aa", "caba") 左边字符串和右边字符串分别包含 1 个和 3 个不同的字符。
("aac", "aba") 左边字符串和右边字符串分别包含 2 个和 2 个不同的字符。这是一个好分割。
("aaca", "ba") 左边字符串和右边字符串分别包含 2 个和 2 个不同的字符。这是一个好分割。
("aacab", "a") 左边字符串和右边字符串分别包含 3 个和 1 个不同的字符。
示例 2:

输入:s = "abcd"
输出:1
解释:好分割为将字符串分割成 ("ab", "cd") 。
示例 3:

输入:s = "aaaaa"
输出:4
解释:所有分割都是好分割。
示例 4:

输入:s = "acbadbaada"
输出:2
 

提示:

s 只包含小写英文字母。
1 <= s.length <= 10^5

这里我感觉代码注释太过于繁琐了,但又怕网友看不懂,所以下面附上了一个没写注释的代码

class Solution {
    /*
        双指针做法,
        前面的搜索前面的个数和,后面的搜索后面的个数和
    
    */
     public int numSplits(String s) {
         //rem1[i]用来记录前i个字符里面不同字符的个数
        int[] rem1=new int[s.length()];
         //s1[i]第i个字符是不是在前面出现过
        boolean[] s1=new boolean[26];
         //rem2[i]用来记录第i个字符后面不同字符的个数
        int[] rem2=new int[s.length()];
         //s2[i]第i个字符是不是在后面出现过
        boolean[] s2=new boolean[26];
         //给第一个和最后一个附上初始值
        rem1[0]=1;
        rem2[s.length()-1]=0;
        s1[s.charAt(0)-'a']=true;
        for(int i=1;i<s.length();i++){
            //如果没出现过,
            if(!s1[s.charAt(i)-'a']) {
                //前面不同的字符数+1
                rem1[i]=rem1[i-1]+1;
                //就把他标记出现
                s1[s.charAt(i)-'a']=true;
            }
            else{
                //如果出现过,不同字符的数量不变,直接用上一个的就行,这个字符不需要更改内容
                rem1[i]=rem1[i-1];
            } 
            //与上面正好相反
            //后面是不是出现过……
            if(!s2[s.charAt(s.length()-i)-'a']){
                rem2[s.length()-1-i]=rem2[s.length()-i]+1;
                s2[s.charAt(s.length()-i)-'a']=true;
            }
            else{
                rem2[s.length()-1-i]=rem2[s.length()-i];
                
            }
        }
        int ans=0;
         //最后统计
        for(int i=0;i<s.length();i++){
            if(rem1[i]==rem2[i]) ans++;
        } 

        return ans;
    }
}

没有注释的代码

class Solution {
    public int numSplits(String s) {
        int[] rem1=new int[s.length()];
        boolean[] s1=new boolean[26];
        int[] rem2=new int[s.length()];
        boolean[] s2=new boolean[26];
        rem1[0]=1;
        rem2[s.length()-1]=0;
        s1[s.charAt(0)-'a']=true;
        for(int i=1;i<s.length();i++){
            if(!s1[s.charAt(i)-'a']) {
                rem1[i]=rem1[i-1]+1;
                s1[s.charAt(i)-'a']=true;
            }
            else{
                rem1[i]=rem1[i-1];
            } 
            if(!s2[s.charAt(s.length()-i)-'a']){
                rem2[s.length()-1-i]=rem2[s.length()-i]+1;
                s2[s.charAt(s.length()-i)-'a']=true;
            }
            else{
                rem2[s.length()-1-i]=rem2[s.length()-i];
                
            }
        }
        int ans=0;
        for(int i=0;i<s.length();i++){
            if(rem1[i]==rem2[i]) ans++;
        } 
        return ans;
    }
}

5459. 形成目标数组的子数组最少增加次数

给你一个整数数组 target 和一个数组 initial ,initial 数组与 target 数组有同样的维度,且一开始全部为 0 。

请你返回从 initial 得到 target 的最少操作次数,每次操作需遵循以下规则:

在 initial 中选择 任意 子数组,并将子数组中每个元素增加 1 。
答案保证在 32 位有符号整数以内。

示例 1:

输入:target = [1,2,3,2,1]
输出:3
解释:我们需要至少 3 次操作从 intial 数组得到 target 数组。
[0,0,0,0,0] 将下标为 04 的元素(包含二者)加 1[1,1,1,1,1] 将下标为 13 的元素(包含二者)加 1[1,2,2,2,1] 将下表为 2 的元素增加 1[1,2,3,2,1] 得到了目标数组。
示例 2:

输入:target = [3,1,1,2]
输出:4
解释:(initial)[0,0,0,0] -> [1,1,1,1] -> [1,1,1,2] -> [2,1,1,2] -> [3,1,1,2] (target) 。
示例 3:

输入:target = [3,1,5,4,2]
输出:7
解释:(initial)[0,0,0,0,0] -> [1,1,1,1,1] -> [2,1,1,1,1] -> [3,1,1,1,1] 
                                  -> [3,1,2,2,2] -> [3,1,3,3,2] -> [3,1,4,4,2] -> [3,1,5,4,2] (target)。
示例 4:

输入:target = [1,1,1,1]
输出:1
 

提示:

1 <= target.length <= 10^5
1 <= target[i] <= 10^5
class Solution {
    /*
        这个题的意思其实我们就可以当作,给target一段区间减相同的数,问最少操作几次可以得到全为0
        这里是正着写的,其实倒着写也是可以的
    
    */
     public int minNumberOperations(int[] target) {
        int ans = 0;
        int n = target.length;
        for(int i = 0; i < n; i++){
            //记录当前值
            int cost = target[i];
            //如果是第一个的话,没办法,最小花费就是它的值
            if(i > 0){
                //看看前面的和当前的值哪个小,就减去哪个,
                //假如前面是4个,当前的值是8个,当前值-最小的就是当前需要花费的,前面四个已经被消去了,可以连带着当前位置的值,
                //相反,如果前面是8个,当前为4个,减去最小的,当前的值为4减去最小的4就为0了,
                cost -= Math.min(cost, target[i - 1]);
            }
            //加上当前最小花费
            ans += cost;
        }
        return ans;
    }
}

你可能感兴趣的:(LeetCode双周赛,LeetCode,Java)