C++程序检查二进制矩阵中的水平和垂直对称性

本文介绍如何用C++编写一个检查二进制矩阵中的水平和垂直对称性的程序。

1. 问题描述

给定一个大小为 n × n 的二进制矩阵，求其中是否存在水平对称和垂直对称的子矩阵。

水平对称子矩阵：从中间一行向上和向下延伸的行相等的子矩阵。

垂直对称子矩阵：从中间一列向左和向右延伸的列相等的子矩阵。

例如，以下二进制矩阵存在垂直对称子矩阵：

1 0 1
0 1 0
1 0 1

2. 解法

我们可以考虑暴力解法，枚举所有的子矩阵，判断是否满足水平对称和垂直对称的条件。时间复杂度为 O(n^6)。

优化的思路是，我们可以用矩阵的前缀和来优化子矩阵的计算。具体地，我们用二维数组 dp[i][j] 表示从矩阵左上角到 (i,j) 的子矩阵是否水平对称，用二维数组 dq[i][j] 表示从矩阵左上角到 (i,j) 的子矩阵是否垂直对称。那么 dp 和 dq 的计算可以用以下的递推公式来表示：

dp[i][j] = dp[i-1][j] && (matrix[i][j] == matrix[n-i+1][j])
dq[i][j] = dq[i][j-1] && (matrix[i][j] == matrix[i][n-j+1])

其中，matrix 为原矩阵。

这样，我们就可以在 O(n^4) 的时间内解决这个问题。

3. 完整代码

下面是用 C++ 实现的完整代码，返回的代码片段按markdown标明：

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<vector<int>> matrix(n+1, vector<int>(n+1));
    vector<vector<bool>> dp(n+1, vector<bool>(n+1, true));
    vector<vector<bool>> dq(n+1, vector<bool>(n+1, true));
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            cin >> matrix[i][j];
        }
    }

    // 计算 dp
    for (int i = 2; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            dp[i][j] = dp[i-1][j] && (matrix[i][j] == matrix[n-i+2][j]);
        }
    }

    // 计算 dq
    for (int i = 1; i <= n; ++i) {
        for (int j = 2; j <= n; ++j) {
            dq[i][j] = dq[i][j-1] && (matrix[i][j] == matrix[i][n-j+2]);
        }
    }

    // 输出结果
    bool found = false;
    for (int len = n; len >= 1; --len) {
        for (int i = 1; i+len-1 <= n; ++i) {
            for (int j = 1; j+len-1 <= n; ++j) {
                if (dp[i+len/2-1][j] && dp[i+len/2][j] && dq[i][j+len/2-1] && dq[i][j+len/2]) {
                    cout << "存在水平和垂直对称的 " << len << " × " << len << " 的子矩阵。" << endl;
                    found = true; // 找到了解
                }
            }
        }
        if (found) {
            break; // 找到了解，退出循环
        }
    }

    if (!found) {
        cout << "不存在水平和垂直对称的子矩阵。" << endl;
    }

    return 0;
}

4. 总结

本文介绍了如何用 C++ 实现一个检查二进制矩阵中的水平和垂直对称性的程序。其中，我们使用矩阵的前缀和来优化子矩阵的计算，将时间复杂度优化到 O(n^4)。