力扣周赛384

3033. 修改矩阵

给你一个下标从 0 开始、大小为 m x n 的整数矩阵 matrix ，新建一个下标从 0 开始、名为 answer 的矩阵。使 answer 与 matrix 相等，接着将其中每个值为 -1 的元素替换为所在列的 最大 元素。

返回矩阵 answer 。

示例 1：

输入：matrix = [[1,2,-1],[4,-1,6],[7,8,9]]
输出：[[1,2,9],[4,8,6],[7,8,9]]
解释：上图显示了发生替换的元素（蓝色区域）。
- 将单元格 [1][1] 中的值替换为列 1 中的最大值 8 。
- 将单元格 [0][2] 中的值替换为列 2 中的最大值 9 。

class Solution {
    public int[][] modifiedMatrix(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[] ma = new int[n];
        int[][] ans = matrix.clone();
        for (int i = 0; i < n; i++) {
            int max = 0;
            for (int j = 0; j < m; j++) {
                if (max < matrix[j][i])
                    max = matrix[j][i];
            }
            ma[i] = max;
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (ans[i][j] == -1)
                    ans[i][j] = ma[j];
            }
        }
        return ans;
    }
}

3034. 匹配模式数组的子数组数目 I

给你一个下标从 0 开始长度为 n 的整数数组 nums ，和一个下标从 0 开始长度为 m 的整数数组 pattern ，pattern 数组只包含整数 -1 ，0 和 1 。

大小为 m + 1 的

子数组

 nums[i..j] 如果对于每个元素 pattern[k] 都满足以下条件，那么我们说这个子数组匹配模式数组 pattern ：

• 如果 pattern[k] == 1 ，那么 nums[i + k + 1] > nums[i + k]
• 如果 pattern[k] == 0 ，那么 nums[i + k + 1] == nums[i + k]
• 如果 pattern[k] == -1 ，那么 nums[i + k + 1] < nums[i + k]

请你返回匹配 pattern 的 nums 子数组的 数目 。

示例 1：

输入：nums = [1,2,3,4,5,6], pattern = [1,1]
输出：4
解释：模式 [1,1] 说明我们要找的子数组是长度为 3 且严格上升的。在数组 nums 中，子数组 [1,2,3] ，[2,3,4] ，[3,4,5] 和 [4,5,6] 都匹配这个模式。
所以 nums 中总共有 4 个子数组匹配这个模式。

示例 2：

输入：nums = [1,4,4,1,3,5,5,3], pattern = [1,0,-1]
输出：2
解释：这里，模式数组 [1,0,-1] 说明我们需要找的子数组中，第一个元素小于第二个元素，第二个元素等于第三个元素，第三个元素大于第四个元素。在 nums 中，子数组 [1,4,4,1] 和 [3,5,5,3] 都匹配这个模式。
所以 nums 中总共有 2 个子数组匹配这个模式。

中间差分

class Solution {
    public int countMatchingSubarrays(int[] nums, int[] pattern) {
        int ans = 0;
        int n = nums.length;
        int m = pattern.length;
        for (int i = 0, j = m - 1; j < n - 1; i++, j++) {
            boolean flag = true;
            for (int k = 0; k < m && flag; k++) {
                int cf = nums[i + k + 1] - nums[i + k];
                int p = jisuan(cf);
                if (p != pattern[k])
                    flag = false;
            }
            if (flag)
                ans++;
        }
        return ans;
    }

    public int jisuan(int k) {
        if (k > 0)
            return 1;
        else if (k < 0)
            return -1;
        else
            return 0;
    }
}

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

给你一个下标从 0 开始的字符串数组 words ，数组的长度为 n ，且包含下标从 0 开始的若干字符串。

你可以执行以下操作 任意 次数（包括零次）：

• 选择整数i、j、x和y，满足0 <= i, j < n，0 <= x < words[i].length，0 <= y < words[j].length，交换 字符 words[i][x] 和 words[j][y] 。

返回一个整数，表示在执行一些操作后，words 中可以包含的

回文串

的 最大 数量。

注意：在操作过程中，i 和 j 可以相等。

示例 1：

输入：words = ["abbb","ba","aa"]
输出：3
解释：在这个例子中，获得最多回文字符串的一种方式是：
选择 i = 0, j = 1, x = 0, y = 0，交换 words[0][0] 和 words[1][0] 。words 变成了 ["bbbb","aa","aa"] 。
words 中的所有字符串都是回文。
因此，可实现的回文字符串的最大数量是 3 。

示例 2：

输入：words = ["abc","ab"]
输出：2
解释：在这个例子中，获得最多回文字符串的一种方式是： 
选择 i = 0, j = 1, x = 1, y = 0，交换 words[0][1] 和 words[1][0] 。words 变成了 ["aac","bb"] 。
选择 i = 0, j = 0, x = 1, y = 2，交换 words[0][1] 和 words[0][2] 。words 变成了 ["aca","bb"] 。
两个字符串都是回文 。
因此，可实现的回文字符串的最大数量是 2。

class Solution {
    public int maxPalindromesAfterOperations(String[] words) {
        int tot = 0;
        int mask = 0; // 奇数个数的字母集合
        for (String w : words) {
            tot += w.length();
            for (char c : w.toCharArray()) {
                mask ^= 1 << (c - 'a');
            }
        }
        tot -= Integer.bitCount(mask); // 减去出现次数为奇数的字母

        Arrays.sort(words, (a, b) -> a.length() - b.length());
        int ans = 0;
        for (String w : words) {
            tot -= w.length() / 2 * 2; // 长为奇数的字符串，长度要减一
            if (tot < 0) break;
            ans++;
        }
        return ans;
    }
}