求所有相等元素的最大平方子矩阵

在一个二维矩阵中，找出所有元素相等的最大平方子矩阵。这个问题可以使用动态规划来解决。

思路

我们可以使用两个动态规划数组来解决这个问题：一个二维数组 $dp[i][j]$ 表示以 $(i, j)$ 为右下角的最大平方子矩阵的边长，另一个一维数组 $height[j]$ 表示以第 $j$ 列为结尾的最大连续相等子序列的长度。

根据问题定义，一个平方子矩阵中的所有元素都是相等的，所以我们只需要考虑这个子矩阵的边长。根据动态规划的思想，我们可以先假设 $(i, j)$ 是一个平方子矩阵的右下角，然后往左上方递推，计算出所有以 $(i, j)$ 为右下角的平方子矩阵的边长，取最大值作为 $dp[i][j]$ 的值。

对于 $height[j]$ 数组，我们可以使用两个指针 $start$ 和 $end$ 来表示当前最大连续相等子序列的起始和终止位置。初始化时，$start$ 和 $end$ 都指向第一列，然后依次遍历每一列，更新 $height[j]$ 数组和平方子矩阵的答案。

代码

以下是 C++ 的代码实现。时间复杂度为 $O(n^3)$，空间复杂度为 $O(n^2)$。

vector<vector<int>> maxSquareSubmatrix(vector<vector<int>>& matrix) {
    int n = matrix.size();
    if (n == 0) return vector<vector<int>>();
    int m = matrix[0].size();
    if (m == 0) return vector<vector<int>>();

    vector<vector<int>> ans;
    vector<vector<int>> dp(n, vector<int>(m));
    vector<int> height(m);

    // 初始化
    for (int j = 0; j < m; j++) {
        dp[0][j] = matrix[0][j];
        height[j] = 1;
        ans.push_back({0, j, 1});
    }

    for (int i = 1; i < n; i++) {
        int start = 0, end = 0;
        for (int j = 0; j < m; j++) {
            if (j > 0 && matrix[i][j - 1] == matrix[i][j]) {
                height[j]++;
            } else {
                height[j] = 1;
                start = end = j;
            }
            while (start >= 0 && end < m) {
                int h = min(height[start], height[end]);
                if (matrix[i - h + 1][start] == matrix[i][j] &&
                    matrix[i - h + 1][end] == matrix[i][j]) {
                    dp[i][j] = max(dp[i][j], h);
                    ans.push_back({i - h + 1, start, h});
                    start--;
                    end++;
                } else {
                    break;
                }
            }
        }
    }

    return ans;
}

示例

以下是一个简单的测试例子：

vector<vector<int>> matrix = {  
    {2, 2, 2, 3, 3, 2},
    {2, 2, 3, 3, 2, 2},
    {2, 3, 3, 2, 2, 2},
    {3, 3, 2, 2, 2, 2}
};

vector<vector<int>> ans = maxSquareSubmatrix(matrix);
for (auto& v : ans) {
    cout << "(" << v[0] << ", " << v[1] << ") - " << v[2] << endl;
}

输出结果：

(0, 0) - 3
(0, 5) - 2
(1, 2) - 2
(1, 3) - 2
(1, 4) - 2
(2, 1) - 2
(2, 2) - 2
(2, 3) - 2
(2, 4) - 2
(3, 0) - 2
(3, 1) - 2