P3392 涂条纹

题目描述

只要一个由 N×M 个小方块组成的旗帜符合如下规则，就是合法的图案。

• 从最上方若干行（至少一行）的格子全部是白色的；
• 接下来若干行（至少一行）的格子全部是蓝色的；
• 剩下的行（至少一行）全部是红色的；

现有一个棋盘状的布，分成了 N 行 M 列的格子，每个格子是白色蓝色红色之一，小 a 希望把这个布改成合法图案，方法是在一些格子上涂颜料，盖住之前的颜色。

小 A 很懒，希望涂最少的格子，使这块布成为一个合法的图案。

输入格式

第一行是两个整数 N,M。

接下来 N 行是一个矩阵，矩阵的每一个小方块是 W（白），B（蓝），R（红）中的一个。

输出格式

一个整数，表示至少需要涂多少块。

输入输出样例

输入 #1复制

4 5
WRWRW
BWRWB
WRWRW
RWBWR

输出 #1复制

11

说明/提示

样例解释

目标状态是：

WWWWW
BBBBB
RRRRR
RRRRR

一共需要改 11 个格子。

数据范围

对于 100% 的数据，N,M≤50。

代码:

1.深搜思想：

#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 50;
const int MAX_M = 50;
int N, M;
char grid[MAX_N][MAX_M];
int cost[MAX_N][3];  // cost[i][0]: W, [1]: B, [2]: R
int min_changes = INT_MAX;
void dfs(int row, int white_rows, int blue_rows, int current_cost, int current_color) {
    if (row == N) {
        if (white_rows >= 1 && blue_rows >= 1 && (N - white_rows - blue_rows) >= 1) {
            min_changes = min(min_changes, current_cost);
        }
        return;
    }
    // 当前行可以选择涂的颜色取决于当前所处的颜色阶段
    // 0: 白色阶段，1: 蓝色阶段，2: 红色阶段
    if (current_color == 0) {
        // 可以选择继续白色或切换到蓝色
        dfs(row + 1, white_rows + 1, blue_rows, current_cost + cost[row][0], 0);
        if (white_rows >= 1) {
            dfs(row + 1, white_rows, blue_rows + 1, current_cost + cost[row][1], 1);
        }
    } else if (current_color == 1) {
        // 可以选择继续蓝色或切换到红色
        dfs(row + 1, white_rows, blue_rows + 1, current_cost + cost[row][1], 1);
        if (blue_rows >= 1) {
            dfs(row + 1, white_rows, blue_rows, current_cost + cost[row][2], 2);
        }
    } else {
        // 只能继续红色
        dfs(row + 1, white_rows, blue_rows, current_cost + cost[row][2], 2);
    }
}

int main() {
    cin >> N >> M;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            cin >> grid[i][j];
        }
    }

    // 预处理每行涂成W/B/R的代价
    for (int i = 0; i < N; ++i) {
        cost[i][0] = cost[i][1] = cost[i][2] = 0;
        for (int j = 0; j < M; ++j) {
            if (grid[i][j] != 'W') cost[i][0]++;
            if (grid[i][j] != 'B') cost[i][1]++;
            if (grid[i][j] != 'R') cost[i][2]++;
        }
    }

    // 初始状态：从第0行开始，白色、蓝色行数为0，当前总代价0，当前颜色阶段为白色
    dfs(0, 0, 0, 0, 0);

    cout << min_changes << endl;

    return 0;
}
2.前缀和：

#include <bits/stdc++.h>  // 包含所有标准库头文件（竞赛常用写法）
using namespace std;

const int MAX_N = 50;  // 定义最大行数
const int MAX_M = 50;  // 定义最大列数

int main() {
    int N, M;  // 实际的行数和列数
    cin >> N >> M;  // 输入行数和列数
    
    char grid[MAX_N][MAX_M];  // 定义静态二维数组存储旗帜当前颜色
    
    // 读取输入数据
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            cin >> grid[i][j];  // 读取每个格子的颜色(W/B/R)
        }
    }
    
    // 预处理：计算每行涂成W/B/R需要改变的格子数
    int cost[MAX_N][3] = {0};  // cost[i][0]:第i行涂W的代价，[1]:B，[2]:R
    
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            // 如果当前不是W，涂W代价+1
            if (grid[i][j] != 'W') cost[i][0]++;
            // 如果当前不是B，涂B代价+1
            if (grid[i][j] != 'B') cost[i][1]++;
            // 如果当前不是R，涂R代价+1
            if (grid[i][j] != 'R') cost[i][2]++;
        }
    }
    
    // 计算前缀和数组，用于快速计算区间和
    int prefix[MAX_N + 1][3] = {0};  // prefix[0][x] = 0
    
    for (int i = 1; i <= N; ++i) {
        // 前i行涂W的总代价
        prefix[i][0] = prefix[i - 1][0] + cost[i - 1][0];
        // 前i行涂B的总代价
        prefix[i][1] = prefix[i - 1][1] + cost[i - 1][1];
        // 前i行涂R的总代价
        prefix[i][2] = prefix[i - 1][2] + cost[i - 1][2];
    }
    
    int min_changes = INT_MAX;  // 初始化最小修改次数为最大值
    
    // 枚举所有可能的分割方式
    for (int i = 1; i <= N - 2; ++i) {  // 白色区域行数(至少1行)
        for (int j = 1; j <= N - i - 1; ++j) {  // 蓝色区域行数(至少1行)
            int k = N - i - j;  // 红色区域行数(剩余行)
            if (k < 1) continue;  // 确保红色区域至少有1行
            
            // 计算当前分割方式的总代价：
            // 前i行涂W的代价 +
            // 中间j行涂B的代价 +
            // 剩余k行涂R的代价
            int total = prefix[i][0] + 
                       (prefix[i + j][1] - prefix[i][1]) + 
                       (prefix[N][2] - prefix[i + j][2]);
            
            // 更新最小代价
            if (total < min_changes) {
                min_changes = total;
            }
        }
    }
    
    // 输出结果
    cout << min_changes << endl;
    
    return 0;
}