[蓝桥杯]整理玩具

整理玩具

题目描述

小明有一套玩具，一共包含 N×MN×M 个部件。这些部件摆放在一个包含 N×MN×M 个小格子的玩具盒中，每个小格子中恰好摆放一个部件。

每一个部件上标记有一个 0 ~ 9 的整数，有可能有多个部件标记相同的整数。

小明对玩具的摆放有特殊的要求：标记相同整数的部件必须摆在一起，组成一个矩形形状。

如以下摆放是满足要求的：

00022

00033

44444

12244

12244

12233

01234

56789

以下摆放不满足要求：

11122

11122

33311

111111

122221

122221

111111

11122

11113

33333

给出一种摆放方式，请你判断是否符合小明的要求。

输入描述

输入包含多组数据。

第一行包含一个整数 T (1≤T≤10)T (1≤T≤10)，代表数据组数。

以下包含 TT 组数据。

每组数据第一行包含两个整数 N,M (1≤N,M≤10)N,M (1≤N,M≤10)。

以下包含 NN 行 MM 列的矩阵，代表摆放方式。

输出描述

对于每组数据，输出 YES 或者 NO 代表是否符合小明的要求。

输入输出样例

示例

输入

3
3 5
00022
00033
44444
3 5
11122
11122
33311
2 5
01234
56789

输出

YES
NO
YES

运行限制

• 最大运行时间：1s
• 最大运行内存: 256M

总通过次数: 256 | 总提交次数: 324 | 通过率: 79%

难度: 困难 标签: 2018, 暴力, 思维, 国赛

算法思路

题目要求判断给定的 N×M 矩阵中，相同数字的部件是否都聚集在一个完整的矩形区域内。核心思路是通过计算每个数字的边界矩形，并验证该矩形内是否完全被该数字填充。

关键步骤：

1. ​边界计算​：对于每个数字（0~9），计算其出现位置的最小行、最大行、最小列、最大列，形成一个边界矩形。
2. ​面积验证​ ：计算边界矩形的面积（行差×列差），并与该数字的出现次数比较：
   • 若面积 = 出现次数 → 数字恰好填满矩形（合法）
   • 若面积 ≠ 出现次数 → 矩形内有其他数字或数字分散（非法）

​​数学原理​ ​：

设数字 d 的边界矩形面积为 S = (max_r - min_r + 1) × (max_c - min_c + 1)

若 S = count[d]，则矩形内无空隙且无非 d 元素（因空隙会减少 d 的实际数量）

示例演示

┌───────────┐
│ 初始化队列 │
│ dist[0]=0  │
└─────┬─────┘
      │
      ▼
┌───────────┐     出队0      ┌───────────┐
│ 队列状态:  │ ───────────▶ │ 扩展邻居: │
│   [0]     │               │ +1→1, +k→3│
└───────────┘               └─────┬─────┘
      │                           │
      ▼                           ▼
┌───────────┐     入队1,3    ┌───────────┐
│ 队列状态:  │ ◀──────────── │ 更新距离: │
│  [1, 3]   │               │ dist[1]=1 │
└───────────┘               │ dist[3]=1 │
      │                     └───────────┘
      │
      ▼
┌───────────┐     出队1      ┌───────────┐
│ 扩展邻居: │ ───────────▶ │ +1→2, +k→4│
└─────┬─────┘               └─────┬─────┘
      │                           │
      ▼                           ▼
┌───────────┐     入队2,4    ┌───────────┐
│ 队列状态:  │ ◀──────────── │ 更新距离: │
│  [3,2,4]  │               │ dist[2]=2 │
└───────────┘               │ dist[4]=2 │
      │                     └───────────┘
      ▼
┌───────────┐     遍历完成    ┌───────────┐
│ 最终dist: │ ───────────▶ │ 0:0,1:1 │
│ [0,1,2,1,2]│               │ 2:2,3:1,4:2│
└───────────┘               └───────────┘

完整代码

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, m;
        cin >> n >> m;
        vector<string> grid(n);
        for (int i = 0; i < n; i++) {
            cin >> grid[i];
        }

        // 初始化边界和计数器
        vector<int> min_r(10, INT_MAX);
        vector<int> max_r(10, INT_MIN);
        vector<int> min_c(10, INT_MAX);
        vector<int> max_c(10, INT_MIN);
        vector<int> count(10, 0);

        // 遍历矩阵更新边界
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                char c = grid[i][j];
                int num = c - '0';
                count[num]++;
                if (i < min_r[num]) min_r[num] = i;
                if (i > max_r[num]) max_r[num] = i;
                if (j < min_c[num]) min_c[num] = j;
                if (j > max_c[num]) max_c[num] = j;
            }
        }

        bool valid = true;
        for (int d = 0; d < 10; d++) {
            if (count[d] == 0) continue; // 跳过未出现的数字

            // 计算矩形面积
            int rows = max_r[d] - min_r[d] + 1;
            int cols = max_c[d] - min_c[d] + 1;
            int area = rows * cols;

            if (area != count[d]) {
                valid = false;
                break;
            }
        }

        cout << (valid ? "YES" : "NO") << endl;
    }
    return 0;
}

代码解析

1. ​​输入处理​​：

   • 读取数据组数 T，循环处理每组数据
   • 读取矩阵尺寸 n, m 和矩阵内容

2. ​​边界初始化​​：

   • min_r/max_r/min_c/max_c：记录每个数字的行列边界（初始化为极值）
   • count：统计每个数字出现次数

3. ​​矩阵遍历​​：

   • 对每个位置 (i, j)，更新对应数字的边界和计数器
   • 边界更新：通过比较当前行列值与存储的极值

4. ​​合法性验证​​：

   • 对每个出现过的数字，计算其边界矩形面积
   • 比较面积与出现次数：不等则标记非法

5. ​​结果输出​​：

   • 所有数字验证通过 → 输出 YES
   • 任意数字验证失败 → 输出 NO

实例验证

测试用例	矩阵	验证过程	结果
合法案例	00022<br>00033<br>44444	0: 面积=2×3=6, 次数=6<br>2: 面积=1×2=2, 次数=2<br>3: 面积=1×2=2, 次数=2<br>4: 面积=1×5=5, 次数=5	YES
非法案例	11122<br>11122<br>33311	1: 面积=3×5=15, 次数=8 → 15≠8	NO
单点矩阵	5	5: 面积=1×1=1, 次数=1	YES

测试点设计

1. ​​基础功能​​：

   • 所有数字形成完整矩形（YES）
   • 数字分散在多区域（NO）
   • 矩形内部有空隙（NO）

2. ​​边界情况​​：

   • 1×1矩阵（YES）
   • 全相同数字（YES）
   • 数字0的特殊处理

3. ​​性能测试​​：

   • 最大矩阵 10×10（运行时间≤1ms）

4. ​​特殊场景​​：

   • 数字出现在边界但内部有空隙（NO）
   • 多个数字相邻但各自成矩形（YES）

注意事项

1. ​​边界初始化​​：

   • 使用 INT_MAX/INT_MIN 确保首次比较正确
   • 未出现数字直接跳过（count[d]=0）

2. ​​行列计算​​：

   • 矩形高度：max_r - min_r + 1
   • 矩形宽度：max_c - min_c + 1

3. ​​字符转换​​：

   • 网格字符转数字：grid[i][j] - '0'
   • 确保输入为数字字符（0~9）

优化建议

1. ​​提前终止​​：

   if (!valid) break; // 发现非法立即终止后续检查

2. ​​合并遍历​​：

   • 若在边界更新时同步计算面积和次数，可减少一轮循环（但代码可读性降低）

3. ​​内存优化​​：

   • 用数组替代 vector（因数据规模小）