这是一个完整的C++数据生成器方案。它不仅包含了题目要求的标准解题逻辑（用于生成.out），还包含了一个精心设计的测试点配置系统（用于生成符合各子任务要求的.in）。

🚀 使用说明

1. 将下方代码保存为 generator.cpp。
2. 确保你的编译器支持 C++11 或更高版本（推荐 C++14/17）。
3. 编译并运行该程序。
4. 程序运行结束后，当前目录下会生成 1.in ~ 10.in 以及对应的 1.out ~ 10.out。
5. 这些文件即为完整的 OJ 测试数据。

📄 数据生成器代码 (C++)

/**
 * P11248 [GESP202409 七级] 矩阵移动 - 数据生成器
 * 包含：
 * 1. 核心解题逻辑 (Solver)
 * 2. 针对不同测试点的参数生成逻辑 (Generator)
 * 3. 自动生成 1.in ~ 10.in 和 1.out ~ 10.out
 */

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <fstream>
#include <random>
#include <ctime>
#include <cstring>

using namespace std;

// ==========================================
// Part 1: 标准解题逻辑 (用于生成 .out 文件)
// ==========================================

const int MAXM = 505;
const int MAXX = 305;
// 滚动数组优化
int dp[2][MAXM][MAXX];

// 单组数据求解函数
int solve_case(int n, int m, int x, const vector<string>& grid) {
    // 初始化
    // 为了防止不同用例间的数据污染，每次求解前需注意清空逻辑
    // 由于使用了滚动数组且在循环内清空，这里不需要全局 memset
    
    // DP 过程
    for (int i = 1; i <= n; ++i) {
        int curr = i % 2;
        int prev = (i - 1) % 2;
        
        // 清空当前行
        for (int j = 0; j <= m; ++j) {
            for (int k = 0; k <= x; ++k) {
                dp[curr][j][k] = -1;
            }
        }
        
        for (int j = 1; j <= m; ++j) {
            char c = grid[i-1][j-1];
            int is_one = (c == '1');
            int is_que = (c == '?');
            
            // 起点处理
            if (i == 1 && j == 1) {
                int start_k = is_que;
                if (start_k > x) start_k = x;
                dp[curr][j][start_k] = is_one;
                continue;
            }
            
            // 状态转移
            for (int k = 0; k <= x; ++k) {
                int next_k = k + is_que;
                if (next_k > x) next_k = x; // 截断
                
                // 从上方转移
                if (i > 1 && dp[prev][j][k] != -1) {
                    dp[curr][j][next_k] = max(dp[curr][j][next_k], dp[prev][j][k] + is_one);
                }
                // 从左方转移
                if (j > 1 && dp[curr][j-1][k] != -1) {
                    dp[curr][j][next_k] = max(dp[curr][j][next_k], dp[curr][j-1][k] + is_one);
                }
            }
        }
    }
    
    // 计算答案
    int ans = 0;
    int curr = n % 2;
    for (int k = 0; k <= x; ++k) {
        if (dp[curr][m][k] != -1) {
            ans = max(ans, dp[curr][m][k] + k);
        }
    }
    return ans;
}

// ==========================================
// Part 2: 数据生成逻辑
// ==========================================

// 随机数生成器
mt19937 rng(time(0));

int random_int(int l, int r) {
    if (l > r) return l;
    return uniform_int_distribution<int>(l, r)(rng);
}

// 生成随机字符：probability_que 是生成 '?' 的概率 (0-100)
// probability_one 是生成 '1' 的概率 (0-100)
// 剩余概率生成 '0'
char random_char(int prob_que, int prob_one) {
    int val = random_int(1, 100);
    if (val <= prob_que) return '?';
    if (val <= prob_que + prob_one) return '1';
    return '0';
}

// 生成一个测试点文件
void generate_test_point(int file_id) {
    string in_filename = to_string(file_id) + ".in";
    string out_filename = to_string(file_id) + ".out";
    
    ofstream fin(in_filename);
    ofstream fout(out_filename);
    
    int T = 0;
    struct TestCase {
        int n, m, x;
        vector<string> grid;
    };
    vector<TestCase> cases;
    
    // -------------------------------------------------
    //  测试点配置策略 (根据题目子任务要求设计)
    // -------------------------------------------------
    
    // 子任务 1 (30%): n,m <= 10, x = 1
    if (file_id <= 3) {
        T = 5;
        for(int t=0; t<T; ++t) {
            int n, m;
            if (file_id == 1) { // 极小数据 & 边界
                if(t == 0) { n=1; m=1; } 
                else { n = random_int(1, 5); m = random_int(1, 5); }
            } else if (file_id == 2) { // 随机小数据
                n = random_int(5, 10); m = random_int(5, 10);
            } else { // 满数据
                n = 10; m = 10;
            }
            int x = 1;
            
            vector<string> grid(n);
            for(int i=0; i<n; ++i) {
                grid[i] = "";
                for(int j=0; j<m; ++j) grid[i] += random_char(33, 33); // 均衡分布
            }
            cases.push_back({n, m, x, grid});
        }
    }
    // 子任务 2 (30%): n,m <= 500, x <= 30
    else if (file_id <= 6) {
        if (file_id == 4) { // 中等规模
            T = 5;
            for(int t=0; t<T; ++t) {
                int n = random_int(40, 60);
                int m = random_int(40, 60);
                int x = random_int(5, 20);
                vector<string> grid(n);
                for(int i=0; i<n; ++i) {
                    grid[i] = "";
                    for(int j=0; j<m; ++j) grid[i] += random_char(20, 40);
                }
                cases.push_back({n, m, x, grid});
            }
        } 
        else if (file_id == 5) { // 特殊形状 (长条形)
            T = 4;
            // 1x500, 500x1, 2x200, 200x2
            vector<pair<int,int>> shapes = {{1, 500}, {500, 1}, {2, 200}, {200, 2}};
            for(auto p : shapes) {
                int n = p.first;
                int m = p.second;
                int x = 30;
                vector<string> grid(n);
                for(int i=0; i<n; ++i) {
                    grid[i] = "";
                    for(int j=0; j<m; ++j) grid[i] += random_char(50, 20); // 多问号
                }
                cases.push_back({n, m, x, grid});
            }
        }
        else { // Subtask 2 极限数据
            T = 1; // 500*500 = 2.5e5，刚好只能放一个
            int n = 500, m = 500, x = 30;
            vector<string> grid(n);
            for(int i=0; i<n; ++i) {
                grid[i] = "";
                for(int j=0; j<m; ++j) grid[i] += random_char(30, 30);
            }
            cases.push_back({n, m, x, grid});
        }
    }
    // 子任务 3 (40%): n,m <= 500, x <= 300
    else {
        if (file_id == 7) { // 大 x 值测试
            T = 5;
            for(int t=0; t<T; ++t) {
                int n = random_int(50, 100);
                int m = random_int(50, 100);
                int x = random_int(100, 300);
                vector<string> grid(n);
                for(int i=0; i<n; ++i) {
                    grid[i] = "";
                    for(int j=0; j<m; ++j) grid[i] += random_char(60, 20); // 大量问号
                }
                cases.push_back({n, m, x, grid});
            }
        }
        else if (file_id == 8) { // 稠密 1 与 稠密 0/问号 对比
            T = 2;
            int dim = 300; // 300*300*2 = 1.8e5 < 2.5e5
            
            // Case 1: 全是问号和1
            vector<string> g1(dim);
            for(int i=0; i<dim; ++i) {
                g1[i] = "";
                for(int j=0; j<dim; ++j) g1[i] += random_char(50, 50);
            }
            cases.push_back({dim, dim, 300, g1});
            
            // Case 2: 稀疏
            vector<string> g2(dim);
            for(int i=0; i<dim; ++i) {
                g2[i] = "";
                for(int j=0; j<dim; ++j) g2[i] += random_char(10, 10);
            }
            cases.push_back({dim, dim, 300, g2});
        }
        else if (file_id == 9) { // 随机混合，尽量填满 2.5e5
            int total_area = 250000;
            int current_area = 0;
            while (current_area < total_area - 2500) { // 留点余地
                int remain = total_area - current_area;
                int n = random_int(10, min(500, (int)sqrt(remain)));
                int m = random_int(10, min(500, remain / n));
                if (n * m > remain) m = remain / n;
                if (n == 0 || m == 0) break;
                
                int x = random_int(1, 300);
                vector<string> grid(n);
                for(int i=0; i<n; ++i) {
                    grid[i] = "";
                    for(int j=0; j<m; ++j) grid[i] += random_char(33, 33);
                }
                cases.push_back({n, m, x, grid});
                current_area += n * m;
                if (cases.size() >= 10) break; // 限制 T <= 10
            }
            T = cases.size();
        }
        else { // Subtask 3 极限数据 (全满)
            T = 1;
            int n = 500, m = 500, x = 300;
            vector<string> grid(n);
            for(int i=0; i<n; ++i) {
                grid[i] = "";
                for(int j=0; j<m; ++j) grid[i] += random_char(40, 30);
            }
            cases.push_back({n, m, x, grid});
        }
    }

    // -------------------------------------------------
    //  写入文件 & 运行 Solver
    // -------------------------------------------------
    
    // 如果 T 没被正确设置 (Case 9 特殊处理外)
    if (T == 0) T = cases.size();
    
    fin << T << "\n";
    cout << "Generating Test Point " << file_id << " (" << T << " cases)..." << endl;
    
    for (const auto& tc : cases) {
        fin << tc.n << " " << tc.m << " " << tc.x << "\n";
        for (const string& row : tc.grid) {
            fin << row << "\n";
        }
        
        // 调用 Solver 计算答案并输出
        int ans = solve_case(tc.n, tc.m, tc.x, tc.grid);
        fout << ans << "\n";
    }
    
    fin.close();
    fout.close();
}

int main() {
    // 加速生成过程中的 IO (虽然对文件流影响有限，但好习惯)
    ios::sync_with_stdio(false);
    cin.tie(0);

    // 生成 1 到 10 号测试点
    for (int i = 1; i <= 10; ++i) {
        generate_test_point(i);
    }

    cout << "All 10 test points generated successfully!" << endl;
    return 0;
}

🎯 测试点设计详解

这份生成器严格按照题目的数据规模与约定进行设计：

• Subtask 1 (30%)：$N, M \le 10, x=1$

  • 1.in: 极小数据（如 $1\times 1$）和边界情况。
  • 2.in: 小规模随机数据 ($5 \times 5$ 至 $10 \times 10$)。
  • 3.in: 该子任务下的最大规模 ($10 \times 10$)。

• Subtask 2 (30%)：$N, M \le 500, x \le 30$

  • 4.in: 中等规模 ($50 \times 50$)，较小的 $x$。
  • 5.in: 特殊形状矩阵（$1 \times 500$ 长条、$500 \times 1$ 竖条），测试边界逻辑。
  • 6.in: 子任务极限 ($500 \times 500$)，数据量大但 $x$ 较小。

• Subtask 3 (40%)：$N, M \le 500, x \le 300$

  • 7.in: $x$ 值很大（接近 300）的情况，配合大量的 ?，测试 $x$ 截断逻辑。
  • 8.in: 稠密 ? 图 与 稠密 1 图的对比，验证策略有效性。
  • 9.in: 随机多组混合数据，严格控制总 $\sum nm \le 2.5 \times 10^5$。
  • 10.in: 全局极限数据 ($500 \times 500, x=300$)，测试最大时间复杂度压力。

⚠️ 注意事项

1. 时间消耗：生成第 6 和 第 10 个点时，因为计算量接近 $7.5 \times 10^7$ 次运算，程序可能会停顿 1-2 秒，这是正常的。
2. 随机性：代码使用了 time(0) 作为种子，每次运行生成的矩阵内容都会不同（但规模固定）。如果你需要每次生成完全一样的数据以便调试，可以将 rng(time(0)) 改为 rng(12345)。

这是一份基于 NOIP C++14 竞赛标准的标准题解代码。

👨‍🏫 教练的解题分析

1. 核心思路

本题是典型的网格图 DP（动态规划）。

• 状态定义：由于“修改多少个问号”直接影响最终得分，且受 $x$ 限制，我们需要将“当前路径上遇到的问号数量”作为 DP 的一个维度。
  • 设 $dp[i][j][k]$ 表示：从起点走到 $(i, j)$，恰好经过 $k$ 个 ? 时，收集到的原本的 1 的最大数量。
• 状态压缩（关键点）：
  • 题目中 $x$ 限制了问号的收益上限。如果路径上问号数量超过 $x$，收益不再增加。
  • 因此，第三维 $k$ 的范围只需要 $0 \sim x$。当问号数量 $> x$ 时，统一视为 $x$ 处理（表示饱和）。
• 最终得分：$Ans = \max(dp[n][m][k] + k)$。

2. 复杂度分析

• 时间复杂度：$O(\sum (n \times m) \times x)$。
  • 根据题目数据，$\sum nm \le 2.5 \times 10^5$，$x \le 300$。
  • 总运算量约为 $7.5 \times 10^7$ 次，C++ 在 1 秒内可以轻松处理（通常限制为 $10^8$ 量级）。
• 空间复杂度：
  • 朴素空间：$500 \times 500 \times 300 \times 4B \approx 300MB$，存在 MLE（内存超限）风险。
  • 优化空间：使用滚动数组。DP 转移只依赖于上一行 $(i-1)$ 和当前行 $(i)$，因此第一维只需要开 2 即可。优化后空间约为 $2 \times 500 \times 300 \times 4B \approx 1.2MB$，非常安全。

💻 标准题解代码 (C++14)

/**
 * P11248 [GESP202409 七级] 矩阵移动
 * 知识点：网格图DP、状态机模型、滚动数组优化
 * 
 * 状态定义：dp[row][col][k] 表示到达 (row, col) 且经过 k 个 '?' 时，
 *          捡到的原本为 '1' 的最大数量。
 *          其中 k 的上限为 x，若超过 x 则记为 x。
 */

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring> // for memset

using namespace std;

// 定义最大常量，防止越界
const int MAXM = 505;
const int MAXX = 305;
const int INF = 0x3f3f3f3f; // 用于标记不可达状态

// 滚动数组：第一维用 2 即可（当前行和上一行交替使用）
int dp[2][MAXM][MAXX];

void solve() {
    int n, m, x;
    cin >> n >> m >> x;
    
    // 读入网格，使用 vector 方便管理，不用担心栈溢出
    vector<string> grid(n);
    for (int i = 0; i < n; ++i) {
        cin >> grid[i];
    }

    // 初始化 DP 数组
    // 注意：多组数据且使用滚动数组，每次处理新的一行时都需要清空
    // 这里先将所有位置初始化为 -1，代表“不可达”
    // 为了性能，我们只在循环内部进行必要的初始化
    
    // 遍历每一行
    for (int i = 1; i <= n; ++i) {
        int curr = i % 2;      // 当前行的滚动索引
        int prev = (i - 1) % 2; // 上一行的滚动索引
        
        // 【易错点1】滚动数组必须显式清空当前行的数据，
        // 否则会残留上一轮 i-2 行的数据导致错误。
        for (int j = 0; j <= m; ++j) {
            for (int k = 0; k <= x; ++k) {
                dp[curr][j][k] = -1;
            }
        }
        
        // 遍历每一列
        for (int j = 1; j <= m; ++j) {
            // 获取当前字符（注意 grid 是 0-indexed，坐标是 1-indexed）
            char c = grid[i-1][j-1];
            
            int is_one = (c == '1'); // 如果是1，原本得分+1
            int is_que = (c == '?'); // 如果是?，状态k需要+1
            
            // 【处理起点 (1,1)】
            if (i == 1 && j == 1) {
                // 如果是问号，k=1；如果是1/0，k=0
                int start_k = is_que; 
                if (start_k > x) start_k = x; // 边界保护（虽然起点最多是1）
                
                dp[curr][j][start_k] = is_one;
                continue; // 起点处理完直接跳过后续转移
            }
            
            // 状态转移：枚举上一步可能的 k 值
            // 我们只需要枚举到 x，因为状态被压缩了
            for (int k = 0; k <= x; ++k) {
                // 计算当前状态的新 k 值
                int next_k = k + is_que;
                if (next_k > x) next_k = x; // 【关键点】截断：超过 x 均视为 x
                
                // 1. 从上方 (i-1, j) 转移
                if (i > 1 && dp[prev][j][k] != -1) {
                    dp[curr][j][next_k] = max(dp[curr][j][next_k], dp[prev][j][k] + is_one);
                }
                
                // 2. 从左方 (i, j-1) 转移
                if (j > 1 && dp[curr][j-1][k] != -1) {
                    dp[curr][j][next_k] = max(dp[curr][j][next_k], dp[curr][j-1][k] + is_one);
                }
            }
        }
    }
    
    // 计算最终答案
    // 终点是 (n, m)，当前滚动行是 n % 2
    int ans = 0;
    int curr = n % 2;
    
    // 遍历终点所有可能的问号收集数量 k
    for (int k = 0; k <= x; ++k) {
        if (dp[curr][m][k] != -1) {
            // 总分 = 原本1的数量(DP值) + 变出的1的数量(k)
            // 注意：因为我们在转移时已经把 >x 的情况压缩为 x，
            // 所以这里直接 +k 即可，无需再取 min(k, x)
            ans = max(ans, dp[curr][m][k] + k);
        }
    }
    
    cout << ans << endl;
}

int main() {
    // 【优化建议】关闭同步流，加速大量数据的 IO
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int t;
    if (cin >> t) {
        while (t--) {
            solve();
        }
    }
    return 0;
}

🔍 易错点与代码细节解读

1. 滚动数组的清空：

   • 在代码中 dp[curr][j][k] = -1 这一步非常关键。
   • 如果不清空，dp[curr] 实际上存储的是 $i-2$ 行的数据（因为是模 2 滚动）。旧数据会干扰新一行的 max 比较，导致答案错误。

2. 起点的特殊处理：

   • 起点没有“上一步”，需要根据起点的字符直接给 DP 数组赋初值。
   • 如果不单独处理，循环内的转移方程会因为访问越界或状态为 -1 而导致起点无法启动。

3. $k$ 的状态截断：

   • 代码中 int next_k = k + is_que; if (next_k > x) next_k = x;。
   • 这是为了防止数组越界，同时也符合题目逻辑：当问号数量超过 $x$ 个，对分数的贡献恒定为 $x$ 分，状态不需要区分 $x+1$ 和 $x+2$，统一记为 $x$ 即可。

4. IO 优化：

   • 题目数据量较大（总和 $2.5 \times 10^5$），建议加上 ios::sync_with_stdio(false); cin.tie(0); 以避免因输入输出过慢导致的 TLE（时间超限）。

你好！很高兴能以教练的身份为你指点这道题目。这是一道非常经典的**网格图动态规划（Grid DP）**变形题。

我们不要急着写代码，先拿出草稿纸，像在黑板前上课一样，把思路一层层剥开。

一、 核心关键词与题意解码

做题的第一步永远是精准读题。请在题目中圈出以下关键词，并思考它们的隐含意义：

1. “只能向下或者向右移动”
   • 隐含意义：典型的网格图模型，无后效性，只会从左方或上方转移过来。这是可以使用 DP 的强烈信号。
2. “修改不超过 $x$ 个 ? 为 1”
   • 隐含意义：这是题目的核心难点。我们不是随意修改，而是为了得分最大化。
   • 得分公式其实可以翻译为：对于一条具体的路径，它的最终得分 = (路径上原本的 1 的数量) + $\min(\text{路径上 `?` 的数量}, x)$。
   • 解释：如果路径上有 $k$ 个问号：
     • 当 $k \le x$ 时，我们可以把它们全部变成 1，得分增加 $k$。
     • 当 $k > x$ 时，我们只能变 $x$ 个，得分增加 $x$。
3. “最优策略”
   • 隐含意义：我们需要在所有可能的路径中，找到上述得分公式计算结果最大的那一条。

二、 预备知识点

解决这道题，你需要掌握：

1. 基础动态规划：特别是网格图（数字三角形模型）的 DP。
2. 多维 DP 状态设计：当简单的 $dp[i][j]$ 无法满足转移需求时，如何增加维度。
3. 空间优化：滚动数组（Rolling Array）技巧，因为 $N, M$ 到了 500，三维数组可能会导致内存紧张（具体看空间限制，但这题用滚动数组更稳妥）。

三、 启发式教学：草稿纸上的推理演练

假设我们在白板前，我会这样引导你思考：

1. 尝试定义最简单的状态（以及为什么它行不通）

学生思路：设 $f[i][j]$ 为走到 $(i, j)$ 能获得的最大分数。 教练反问：假设 $x=2$。

• 路径 A 到达某点：收集了 2 个 1，0 个 ?。当前得分 $2 + 0 = 2$。
• 路径 B 到达某点：收集了 0 个 1，2 个 ?。当前得分 $0 + 2 = 2$。
• $f[i][j]$ 记录最大分，两者都是 2，看起来没区别。
• 下一步：如果下一个格子是 ?。
  • 路径 A 变成了：2 个 1，1 个 ?。得分 $2 + 1 = 3$。
  • 路径 B 变成了：0 个 1，3 个 ?。得分 $0 + \min(3, 2) = 2$（因为 $x=2$，问号收益封顶了）。
• 结论：同样的当前分数，面对同样的未来（下一个 ?），产生的后续结果不同！说明只记录分数是不够的，丢失了“目前用了多少个问号”这个关键信息。

2. 升维：把丢失的信息找回来

教练引导：既然“问号的数量”影响未来的得分潜力，那我们就把它加到状态里去。

新状态定义： $dp[i][j][k]$ 表示从 $(1,1)$ 走到 $(i,j)$，恰好经过了 $k$ 个 ? 时，所能收集到的原本的 1 的最大数量。

• 为什么存“1 的数量”而不是总分？
  • 因为总分是计算出来的：$Score = dp[i][j][k] + \min(k, x)$。将 1 和 ? 分开记录，逻辑更清晰。

3. 处理 $k$ 的范围（关键优化）

教练提问：$N, M$ 最大 500，路径最长 $N+M \approx 1000$。如果 $k$ 维开到 1000，$500 \times 500 \times 1000$ 大约 2.5 亿次运算，对于多组数据可能超时。我们需要优化 $k$。 请看得分公式：$Score = \text{Ones} + \min(k, x)$。

• 如果我已经遇到了 $x$ 个问号，再遇到第 $x+1$ 个问号，对“问号部分的得分”有贡献吗？（没有，被 $x$ 封顶了）。
• 所以，我们是否需要区分“$x$ 个问号”和“$x+5$ 个问号”的区别？
  • 不需要。我们可以把状态 $k$ 的含义修改为：
    • $0, 1, \dots, x-1$：表示恰好经过这么多问号。
    • $x$：表示经过了 $\ge x$ 个问号。

优化后的复杂度：$O(T \times N \times M \times x)$。根据题目数据 $\sum nm \le 2.5 \times 10^5$ 且 $x \le 300$，计算量约为 $7.5 \times 10^7$，在 1 秒的时限内是安全的。

4. 状态转移方程推导

对于位置 $(i, j)$ 的字符 $C$，我们要从 $(i-1, j)$ 或 $(i, j-1)$ 转移过来。假设上一步的状态是 $k_{prev}$，1 的数量是 $val_{prev}$。

• 如果 $C$ 是 '0':
  • 问号数不变，1 数不变。
  • $dp[i][j][k] = \max(\dots, val_{prev})$
• 如果 $C$ 是 '1':
  • 问号数不变，1 数 +1。
  • $dp[i][j][k] = \max(\dots, val_{prev} + 1)$
• 如果 $C$ 是 '?':
  • 问号数 +1。注意如果 $k_{prev} == x$，加 1 后状态仍记作 $x$（表示饱和）。
  • 1 数不变。
  • $dp[i][j][\min(k_{prev}+1, x)] = \max(\dots, val_{prev})$

四、 教练的 Coding 提示（空间与细节）

1. 初始化：
   • DP 数组初始化为一个负数（如 -1），表示“不可达”。
   • 起点的处理：$(1,1)$ 根据是 0/1/? 初始化对应的 $dp[1][1][\dots]$。
2. 空间优化（进阶）：
   • 你现在的 DP 数组是 dp[505][505][305]，大概需要 $300\text{MB}$ 内存（int 4字节）。这在很多比赛中会 MLE（内存超限）。
   • 观察发现，计算第 $i$ 行只需要第 $i$ 行（左边）和第 $i-1$ 行（上边）的数据。
   • 可以使用滚动数组，把第一维 $N$ 压缩成 2，即 dp[2][505][305]，内存瞬间降到几 MB。
3. 最终答案：
   • 遍历终点 $dp[n][m][k]$ 的所有可能的 $k$ ($0 \le k \le x$)。
   • 答案 = $\max(dp[n][m][k] + k)$。
   • 注意：这里不需要 $\min(k, x)$，因为我们的状态定义里 $k$ 最大就是 $x$（代表 $\ge x$），加上 $x$ 刚好符合逻辑。

总结思路流程

1. 读题：识别这是带“背包容量”限制的网格图 DP。
2. 状态：$dp[i][j][k]$ 表示位置 $(i,j)$ 遇到 $k$ 个问号时的最大原本 1 数量。
3. 截断：$k$ 超过 $x$ 视为 $x$。
4. 转移：根据当前字符是 0/1/? 进行分类转移。
5. 统计：终点处枚举所有 $k$ 计算总分取最大。

现在，请拿起笔，尝试写出具体的转移代码结构吧！加油！