mini_ceo_1

def get_all_2x2_positions(n):
    positions = []
    for i in range(n-1):
        for j in range(n-1):
            positions.append((i, j))
    return positions

def get_2x2_colors(board, i, j):
    return {
        board[i][j],
        board[i][j+1],
        board[i+1][j],
        board[i+1][j+1]
    }

def find_unbalanced_squares(board, n):
    all_colors = {'R', 'G', 'B'}
    unbalanced = []
    for i, j in get_all_2x2_positions(n):
        colors = get_2x2_colors(board, i, j)
        if len(colors) < 3:
            missing = all_colors - colors
            unbalanced.append((i, j, missing))
    return unbalanced

def find_best_recolor(board, unbalanced):
    count = {}
    for i, j, missing_colors in unbalanced:
        for mi in missing_colors:
            for di in range(2):
                for dj in range(2):
                    ii, jj = i + di, j + dj
                    if board[ii][jj] != mi:
                        key = (ii, jj, mi)
                        count[key] = count.get(key, 0) + 1
    if not count:
        return None
    best = max(count, key=count.get)
    return best

def recolor_cell(board, i, j, color):
    board[i][j] = color

def min_recolorings(board):
    n = len(board)
    changes = 0
    board = [row[:] for row in board]
    while True:
        unbalanced = find_unbalanced_squares(board, n)
        if not unbalanced:
            break
        cell = find_best_recolor(board, unbalanced)
        if not cell:
            break
        i, j, color = cell
        recolor_cell(board, i, j, color)
        changes += 1
    return changes

board = [
    ['R', 'B', 'R', 'B', 'R', 'B'],
    ['G', 'R', 'G', 'R', 'G', 'R'],
    ['B', 'G', 'B', 'G', 'B', 'G'],
    ['R', 'B', 'R', 'B', 'R', 'B'],
    ['G', 'R', 'G', 'R', 'G', 'R'],
    ['B', 'G', 'B', 'G', 'B', 'G'],
]

print(min_recolorings(board))