Leetcode - 周赛384

一，3033. 修改矩阵

这道题直接暴力求解，先算出每一列的最大值，再将所有为-1的区域替换成该列的最大值，代码如下：

class Solution {
    public int[][] modifiedMatrix(int[][] matrix) {
        int n = matrix.length;
        int m = matrix[0].length;
        int[] max = new int[m];
        for(int j=0; j<m; j++){
            for(int i=0; i<n; i++){//得到每列的最大值
                max[j] = Math.max(max[j],matrix[i][j]);
            }
        }
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
               if(matrix[i][j] == -1){//是-1就进行替换
                   matrix[i][j] = max[j];
               }
            }
        }
        return matrix;
    }
}

二，3035. 回文字符串的最大数量

这道题是问我们：怎样交换可以使words数组包含最大数量的回文串，注意只要输出回文串的最大数量。再仔细看题就会发现，这些数组中字符都是可以相互交换的，也就是说，我们可以先使用hash或者int[26]（题目说了只包含小写字母）来统计一下words数组中包含哪些字符及其对应的数目，再自己构造出固定长度的回文字符串。

这时还有一个问题，就是如何保证我们构造的字符串的数目一定是最大的，这里我们就要使用贪心的思想了，我们可以先得到words数组中字符串的长度，并将其从小到大排序，再根据长度从小到大来构造回文字符串，这样就可以保证构造出的回文字符串的数目是最大的。

其实再进一步想一想，回文字符串的特点是什么？不就是对称吗，也就是说我们根本不需要知道各个字符的数量，只需要知道，有多少成对的字符（使用two代替），又有多少单个字符（使用one来代替）。

大体思路想好了，剩下的就是如何构造字符串（假设我们要构造长度为x的回文字符串）：

1）剩下的字符可以构造出字符串，即 two - x/2 >= 0 && one - x%2 >= 0，同时ans++

2）剩下的字符不可以构造出字符串:

缺少成对的字符，这时直接返回，因为我们是从小到大来构造字符串的，如果这个构造的字符串缺少成对的字符，那么后面的也一定缺少，即 two - x/2 < 0
缺少单个字符，即 one - x%2 < 0，这时候我们要看two是否还多余，如果多余，我们可以从two中拿出一个，同时ans++ (注意：当我们从two中拿出一个时，我们的one也要同时+1，相当于是将一个成对的字符拆成单个字符来使用)，如果缺少，直接返回。

进阶：上述讨论的2.2这种情况真的存在吗？

我们这样想一想，当答案就等于words.length的时候，two是最大的，one是最小的，而当one是最小的时候，他也能满足单个字符的需求，也就是说，我们不需要关心one，只需要关心two，即 two - x/2 >= 0 或者 two - x/2 < 0，当 >= 0 时， ans++；当 < 0 时，直接返回答案。

上代码：

class Solution {
    public int maxPalindromesAfterOperations(String[] words) {

        int[] m = new int[26];//统计各个字符出现的次数
        int[] t = new int[words.length];//统计words数组中字符串的长度
        for(int i=0; i<words.length; i++){
            t[i] = words[i].length(); 
            for(char ch : words[i].toCharArray()){
                m[ch-'a']++;
            }
        }

        Arrays.sort(t);//从小到大排序
        int two = 0;//统计成对字符的数目
        for(int i=0; i<26; i++){
            two += m[i]/2;
        }

        int ans = 0;
        for(int x : t){//从小到大构造回文字符串
            if(two-x/2>=0){
                two -= x/2;
                ans++;
            }else{
                return ans;
            }
        }

        return ans;    
    }
}

三，3036. 匹配模式数组的子数组数目 II

这周周赛的二四题是相同的，这里就一起讲了。

该题的关键点在于是否能将这道题转换成一个 "字符串匹配" 问题：

我们通过题目给的条件：

nums[i] - nums[i-1] > 0，t[i-1] = 1
nums[i] - nums[i-1] == 0, t[i-1] = 0
nums[i] - nums[i-1] < 0, t[i-1] = -1

可以得到一个 int[] t = new int[nums.length-1] 的数组，然后通过kmp算法求数组 t 中有多少和数组pattern相同的字数组。

代码如下：

class Solution {
    public int countMatchingSubarrays(int[] nums, int[] pattern) {
        int n = nums.length;
        int[] t = new int[n-1];
        for(int i=1; i<n; i++){
            if(nums[i]-nums[i-1]==0)
                t[i-1] = 0;
            else if(nums[i]-nums[i-1]>0)
                t[i-1] = 1;
            else 
                t[i-1] = -1;
        }
        //求next数组
        int k = pattern.length;
        int[] next = new int[k];
        for(int i=1, j=0; i<k; i++){
            while(j>0&&pattern[i]!=pattern[j]){
                j = next[j-1];
            }
            if(pattern[i]==pattern[j])
                j++;
            next[i] = j;
        }
        //字符串匹配
        int ans = 0;
        for(int i=0, j=0; i<n-1; i++){
            while(j>0&&j<k&&t[i]!=pattern[j]){
                j = next[j-1];
            }
            if(t[i]==pattern[j])
                j++;
            if(j==k){
                j = next[j-1];
                ans++;
            }
        }

        return ans;
    }
}

除了KMP算法之外，还可以通过Z函数算法来求解，下面简单来讲一讲Z函数算法的思想：和KMP的思路差不多，只不过kmp中的 next 数组是用来求字符串中的最长前后缀，而Z函数中的 z 数组则是用来求字符串的最长前前缀，举一个例子：

使用该方法麻烦的点是：需要手动的将 pattern 数组添加到 t 数组的前面，然后只需要统计 z[i] （i >= pattern.length）大于等于 pattern.length 的数目就行了。

class Solution {
    public int countMatchingSubarrays(int[] nums, int[] pattern) {
        int n = nums.length;
        int[] t = new int[n-1];
        for(int i=1; i<n; i++){
            if(nums[i]-nums[i-1]==0)
                t[i-1] = 0;
            else if(nums[i]-nums[i-1]>0)
                t[i-1] = 1;
            else 
                t[i-1] = -1;
        }

        List<Integer> ls = new ArrayList<>();
        for(int x : pattern) ls.add(x);
        for(int x : t) ls.add(x);

        int ans = 0;
        int k = pattern.length;
        int[] z = new int[ls.size()];
        int l=0, r=0;
        for(int i=1; i<ls.size(); i++){
            if(i <= r)
                z[i] = Math.min(z[i-l], r-i+1);
            while(i+z[i]<ls.size() && ls.get(z[i]) == ls.get(i+z[i])){
                l = i;
                r = i + z[i];
                z[i]++;
            }
            if(i>=k && z[i]>=k) 
                ans++;
        }
        return ans;
    }
}