8月算法训练------第六天（滑动窗口）解题报告

题目类型：滑动窗口
题目难度：简单

第一题、1984. 学生分数的最小差值

1. 题目链接：1984. 学生分数的最小差值
2. 思路分析：
   先将数组进行排序，然后按固定窗口长度k来取，当i-j的值大于k时，就将i++，如果i-j的值等于k时，就计算滑动窗口中最大值与最小值的差，最后返回这些差值的最小值。
3. 代码：

class Solution {
    public int minimumDifference(int[] nums, int k) {
        if(k == 1) return 0;
        Arrays.sort(nums);
        int i = 0, j = 0;
        int min = 100000;
        while(j < nums.length){
            if(j - i + 1 > k){
                i++;
            }
            if(j - i + 1 == k){
                min = Math.min(min, nums[j] - nums[i]);
            }
            j++;
        }
        return min;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

第二题、1876. 长度为三且各字符不同的子字符串

1. 题目链接：1876. 长度为三且各字符不同的子字符串

2. 思路分析：
   因为子串的长度固定为3，所以只需要截取每个长度为3的子字符串，判断这些子字符串中的字符是否重复，如果重复，就不算，三个都不重复时，才将其加上。

3. 代码：

class Solution {
    public int countGoodSubstrings(String s) {
        if(s.length() < 3) return 0;
        int res = 0;
        for(int i = 0; i <= s.length() - 3; i++){
            String sub = s.substring(i, i+3);
            if(sub.charAt(0) != sub.charAt(1) && sub.charAt(0) != sub.charAt(2) && sub.charAt(2) != sub.charAt(1)){
                res++;
            }
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

第三题、1839. 所有元音按顺序排布的最长子字符串

1. 题目链接：1839. 所有元音按顺序排布的最长子字符串
2. 思路分析：
   将aeiou存入HashMap中，遍历整个字符串，如果当前位与前一位的差值为1或0，这种情况是正常情况，如果start位是a且end位是u，就将其加上；
   如果差不为1或0，则将start从end开始再遍历
3. 代码：

class Solution {
    public int longestBeautifulSubstring(String word) {
        int n = word.length();
        Map<Character, Integer> valueMap = new HashMap();
        valueMap.put('a',0);
        valueMap.put('e',1);
        valueMap.put('i',2);
        valueMap.put('o',3);
        valueMap.put('u',4);

        char[] nums = word.toCharArray();
        int start=0,end=0;
        int res = 0;
        while(end<n-1) {
            end++;
            if(nums[start] == 'a' && (valueMap.get(nums[end-1])+1 == valueMap.get(nums[end]) ||
            	 valueMap.get(nums[end-1]) == valueMap.get(nums[end]))) {
                if(nums[start] == 'a' && nums[end] == 'u') {
                    res = Math.max(end-start+1, res);
                }
            } else {
                start = end;
            }
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

剑指offer

题目类型：排序
难度：简单

第四题、剑指 Offer 61. 扑克牌中的顺子

1. 题目链接：剑指 Offer 61. 扑克牌中的顺子
2. 思路分析：
   当数组中有重复数字且这个数字不是0，那么这个数组必不可能是顺子；
   然后我们需要再遍历一边数组，统计数组中0出现的次数，当数组中非0数字之间的差为1，或者小于等于0的个数，就认为能组成顺子，否则，不能组成顺子。
3. 代码：

class Solution {
    public boolean isStraight(int[] nums) {
        Arrays.sort(nums);
        for(int i = 0; i < nums.length - 1; i++){
            if(nums[i] == nums[i+1] && nums[i] != 0){
                return false;
            }
        }
        int pre = 0;
        boolean flag = false;
        for(int i = 0; i < nums.length - 1; i++){
            if(nums[i] == 0){
                pre++;
            }else{
                if((nums[i+1] - nums[i] == 1) || (nums[i+1] - nums[i] <= pre + 1)){
                    flag = true;
                }else{
                    return false;
                }
            }
        }
        return flag;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

第五题、剑指 Offer 45. 把数组排成最小的数

1. 题目链接：剑指 Offer 45. 把数组排成最小的数
2. 思路分析：
   这一题要定义一个新的排序规则：
   当字符串x+y < y+x那么x小于y；
   当字符串x+y > y+x那么x大于y；
   就将小的加入到答案中。
3. 代码：

class Solution {
    public String minNumber(int[] nums) {
        String[] strs = new String[nums.length];
        for(int i = 0; i < nums.length; i++)
            strs[i] = String.valueOf(nums[i]);
        Arrays.sort(strs, (x, y) -> (x + y).compareTo(y + x));
        StringBuilder res = new StringBuilder();
        for(String s : strs)
            res.append(s);
        return res.toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12