给你一个下标从 0 开始、大小为 n x n 的矩阵 grid ，其中 n 为奇数，且 grid[r][c] 的值为 0 、1 或 2 。
如果一个单元格属于以下三条线中的任一一条，我们就认为它是字母 Y 的一部分：
从左上角单元格开始到矩阵中心单元格结束的对角线。
从右上角单元格开始到矩阵中心单元格结束的对角线。
从中心单元格开始到矩阵底部边界结束的垂直线。
当且仅当满足以下全部条件时，可以判定矩阵上写有字母 Y ：
属于 Y 的所有单元格的值相等。
不属于 Y 的所有单元格的值相等。
属于 Y 的单元格的值与不属于Y的单元格的值不同。
每次操作你可以将任意单元格的值改变为 0 、1 或 2 。返回在矩阵上写出字母 Y 所需的 最少 操作次数。
示例 1：
输入：grid = [[1,2,2],[1,1,0],[0,1,0]]
输出：3
解释：将在矩阵上写出字母 Y 需要执行的操作用蓝色高亮显示。操作后，所有属于 Y 的单元格（加粗显示）的值都为 1 ，而不属于 Y 的单元格的值都为 0 。
可以证明，写出 Y 至少需要进行 3 次操作。
示例 2：
输入：grid = [[0,1,0,1,0],[2,1,0,1,2],[2,2,2,0,1],[2,2,2,2,2],[2,1,2,2,2]]
输出：12
解释：将在矩阵上写出字母 Y 需要执行的操作用蓝色高亮显示。操作后，所有属于 Y 的单元格（加粗显示）的值都为 0 ，而不属于 Y 的单元格的值都为 2 。
可以证明，写出 Y 至少需要进行 12 次操作。
class Solution {
public:
int minimumOperationsToWriteY(vector<vector<int>> &grid) {
int cnt1[3]{}, cnt2[3]{};
int n = grid.size();
int m = n / 2;
for (int i = 0; i < m; i++) {
cnt1[grid[i][i]]++;
cnt1[grid[i][n - 1 - i]]++;
for (int j = 0; j < n; j++) {
if (j != i && j != n - 1 - i) {
cnt2[grid[i][j]]++;
}
}
}
for (int i = m; i < n; i++) {
cnt1[grid[i][m]]++;
for (int j = 0; j < n; j++) {
if (j != m) {
cnt2[grid[i][j]]++;
}
}
}
int max_not_change = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
max_not_change = max(max_not_change, cnt1[i] + cnt2[j]);
}
}
}
return n * n - max_not_change;
}
};
func minimumOperationsToWriteY(grid [][]int) int {
var cnt1, cnt2 [3]int
n := len(grid)
m := n / 2
for i, row := range grid[:m] {
cnt1[row[i]]++
cnt1[row[n-1-i]]++
for j, x := range row {
if j != i && j != n-1-i {
cnt2[x]++
}
}
}
for _, row := range grid[m:] {
cnt1[row[m]]++
for j, x := range row {
if j != m {
cnt2[x]++
}
}
}
maxNotChange := 0
for i, c1 := range cnt1 {
for j, c2 := range cnt2 {
if i != j {
maxNotChange = max(maxNotChange, c1+c2)
}
}
}
return n*n - maxNotChange
}
class Solution {
public int minimumOperationsToWriteY(int[][] grid) {
int[] cnt1 = new int[3];
int[] cnt2 = new int[3];
int n = grid.length;
int m = n / 2;
for (int i = 0; i < m; i++) {
cnt1[grid[i][i]]++;
cnt1[grid[i][n - 1 - i]]++;
for (int j = 0; j < n; j++) {
if (j != i && j != n - 1 - i) {
cnt2[grid[i][j]]++;
}
}
}
for (int i = m; i < n; i++) {
cnt1[grid[i][m]]++;
for (int j = 0; j < n; j++) {
if (j != m) {
cnt2[grid[i][j]]++;
}
}
}
int maxNotChange = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
maxNotChange = Math.max(maxNotChange, cnt1[i] + cnt2[j]);
}
}
}
return n * n - maxNotChange;
}
}
class Solution:
def minimumOperationsToWriteY(self, grid: List[List[int]]) -> int:
cnt1 = [0] * 3 # 记录属于Y的单元格，0,1,2各自出现次数
cnt2 = [0] * 3 # 记录不属于Y的单元格，0,1,2各自出现次数
n = len(grid)
m = n // 2
for i, row in enumerate(grid[:m]):
cnt1[row[i]] += 1
cnt1[row[-1 - i]] += 1
for j, x in enumerate(row):
if j != i and j != n - 1 - i:
cnt2[x] += 1
for row in grid[m:]:
cnt1[row[m]] += 1
for j, x in enumerate(row):
if j != m:
cnt2[x] += 1
max_not_change = 0 # 最多几个元素保持不变
for i, c1 in enumerate(cnt1):
for j, c2 in enumerate(cnt2):
if i != j: # Y中元素变i，不在Y中元素变j
max_not_change = max(max_not_change, c1 + c2)
return n * n - max_not_change
