小美的好矩阵

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        scanner.nextLine();
        char[][] matrix = new char[n][m];
        for (int i = 0; i < n; i++) {
            matrix[i] = scanner.nextLine().toCharArray();
        }

        int result = 0; // 好矩阵的数量

        // 遍历每个3x3子矩阵
        for (int i = 0; i <= n - 3; i++) {
            for (int j = 0; j <= m - 3; j++) {
                if (isGood(matrix, i, j)) {
                    // 符合条件的使result++
                    result++;
                }
            }
        }
        System.out.println(result);
    }

    // 判断子矩阵是否满足2个条件
    private static boolean isGood(char[][] matrix, int row, int col) {
        Set<Character> set = new HashSet<>();

        for (int x = row; x < row + 3; x++) {
            for (int y = col; y < col + 3; y++) {
                char ch = matrix[x][y];
                set.add(ch);
                // 相邻相等的话，跟右边和跟下面的字符相比较就OK
                if (ch >= 'D' || (y + 1 < col + 3 && ch == matrix[x][y + 1]) || (x + 1 < row + 3 && ch == matrix[x + 1][y])) {
                    return false;
                }
            }
        }
        // 到了这一步表明相邻的字符没有相等的，只剩下判断ABC是否都出现过即可
        return set.size() == 3;
    }
}

n,m=[int(i) for i in input().split(' ')]
matrix=[]

for i in range(n):
    matrix.append([j for j in input()])

def judge(matrix, row, col):
    uni_ch=set()
    for x in range(row,row+3):
        for y in range(col,col+3):
            ch=matrix[x][y]
            uni_ch.add(ch)
            if ch >= 'D'&nbs***bsp;(y + 1 < col + 3 and ch == matrix[x][y + 1])&nbs***bsp;(x + 1 < row + 3 and ch == matrix[x + 1][y]):
                return False
    return len(uni_ch)==3
res=0
for i in range(0,n-2):
    for j in range(0,m-2):
        if judge(matrix,i,j):
            res+=1
print(res)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2023/11/3 19:34
# @Author  : lanlin
# 小美的好矩阵


def judge33(matrix, y, x):
    result = True

    flag_x = [-1, 0, 1, -1, 0, 1, -1, 0, 1]
    flag_y = [-1, -1, -1, 0, 0, 0, 1, 1, 1]

    flag_ABC = set()
    for i in range(len(flag_y)):

        xx = x+flag_x[i]
        yy = y+flag_y[i]

        temp = matrix[yy][xx]

        # 判断三种字符是否都出现过，且没有其他字符
        if temp in ['A','B','C']:
            flag_ABC.add(temp)
        else:
            return False

        # 判断字符重复，每个元素只需判断其下、右两元素即可
        if (yy+1)<(y+2) and temp == matrix[yy+1][xx]:
            return False
        if (xx+1)<(x+2) and temp == matrix[yy][xx+1]:
            return False

    if len(flag_ABC) != 3:
        result = False

    return result


def judge(data, m, n):
    result = 0
    for y in range(m-2):
        for x in range(n-2):
            if judge33(data, y+1, x+1):
                result += 1
    return result


if __name__=='__main__':
    array1 = input().split(" ")
    m = int(array1[0])
    n = int(array1[1])

    data_array = []

    for i in range(m):
        temp_list = list(input())
        data_array.append(temp_list)

    print(judge(data_array, m, n))

'''
4 4
DABC
ABAB
BABA
BBAB
'''

package main
 
import (
    "fmt"
)
 
func main() {
    var n, m int
    fmt.Scan(&n, &m)
 
    if n < 3 || m < 3 {
        fmt.Println(0)
        return
    }
 
    matrix := make([][]byte, n)
    for i := 0; i < n; i++ {
        var str string
        fmt.Scan(&str)
        strByte := []byte(str)
 
        matrix[i] = make([]byte, m)
        for j := 0; j < m; j++ {
            matrix[i][j] = strByte[j]
        }
    }
 
    good := 0
    for i := 0; i < n-2; i++ {
        for j := 0; j < m-2; j++ {
            // i, j 作为起点
            if isGood(matrix, i, j) {
                good++
            }
        }
    }
 
    fmt.Println(good)
 
}
 
func isGood(matrix [][]byte, row, col int) bool {
    hasA, hasB, hasC := false, false, false
    for i := row; i < row+3; i++ {
        for j := col; j < col+3; j++ {
            ch := matrix[i][j]
            if ch != 'A' && ch != 'B' && ch != 'C' {
                return false
            }
            if ch == 'A' {
                hasA = true
            } else if ch == 'B' {
                hasB = true
            } else if ch == 'C' {
                hasC = true
            } else {
                return false
            }
        }
    }
    if !(hasA && hasB && hasC) {
        return false
    }
 
    for i := row; i < row+2; i++ {
        for j := col; j < col+3; j++ {
            if matrix[i][j] == matrix[i+1][j] {
                return false
            }
        }
    }
 
    for i := row; i < row+3; i++ {
        for j := col; j < col+2; j++ {
            if matrix[i][j] == matrix[i][j+1] {
                return false
            }
        }
    }
 
    return true
}