C++编程，有没有好的见解，最好是wanzheng代码
跟踪系统利用雷达扫描周围空间,扫描结果表示为 NxM 的矩阵。如果在相应的位置没有
障碍物，则矩阵的元素为 0；若有,则为 1。矩阵保存在一个文件中，文件名由用户输入。
矩阵大小由#define 预先定义。矩阵中每个元素都由空格分隔。
编一个程序，读取矩阵。并且
1.计算水平方向上的最长屏障， 即返回矩阵中水平方向
上，1 连续出现次数最多的位置和相应长度；
2.同样计算竖直方向上的最长屏障， 即
返回矩阵中竖直方向上，1 连续出现次数最多的位置和相应长度；
3. 计算正对角方向上
的最长屏障，即返回矩阵中正对角方向上，
1 连续出现次数最多的位置和相应长度；
4. 计
算逆对角方向上的最长屏障，即返回矩阵中逆对角方向上，1 连续出现次数最多的位置
和相应长度；
5.判定这 4 个最长屏障有无共用元素。
如果出现长度相同的， 则选择最后一个作为结果。
（这两天就需要）
（我用的是DevC++编程）
#include <iostream>
#include <fstream>
#include <vector>
#define N 5 // 矩阵大小
// 计算水平方向上的最长屏障
std::pair<int, int> calculateHorizontalBarrier(const std::vector<std::vector<int>>& matrix) {
int max_length = 0;
int max_index = -1;
int current_length = 0;
int current_index = -1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (matrix[i][j] == 1) {
if (current_index == -1) {
current_index = i;
}
current_length++;
}
else {
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
current_length = 0;
current_index = -1;
}
}
}
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
return std::make_pair(max_index, max_length);
}
// 计算竖直方向上的最长屏障
std::pair<int, int> calculateVerticalBarrier(const std::vector<std::vector<int>>& matrix) {
int max_length = 0;
int max_index = -1;
int current_length = 0;
int current_index = -1;
for (int j = 0; j < N; j++) {
for (int i = 0; i < N; i++) {
if (matrix[i][j] == 1) {
if (current_index == -1) {
current_index = j;
}
current_length++;
}
else {
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
current_length = 0;
current_index = -1;
}
}
}
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
return std::make_pair(max_index, max_length);
}
// 计算正对角方向上的最长屏障
std::pair<int, int> calculateDiagonalBarrier(const std::vector<std::vector<int>>& matrix) {
int max_length = 0;
int max_index = -1;
int current_length = 0;
int current_index = -1;
for (int k = 0; k < N; k++) {
for (int i = 0; i < N - k; i++) {
int j = i + k;
if (matrix[i][j] == 1) {
if (current_index == -1) {
current_index = i;
}
current_length++;
}
else {
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
current_length = 0;
current_index = -1;
}
}
}
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
return std::make_pair(max_index, max_length);
}
// 计算逆对角方向上的最长屏障
std::pair<int, int> calculateInverseDiagonalBarrier(const std::vector<std::vector<int>>& matrix) {
int max_length = 0;
int max_index = -1;
int current_length = 0;
int current_index = -1;
for (int k = 0; k < N; k++) {
for (int i = 0; i < N - k; i++) {
int j = N - 1 - i - k;
if (matrix[i][j] == 1) {
if (current_index == -1) {
current_index = i;
}
current_length++;
}
else {
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
current_length = 0;
current_index = -1;
}
}
}
if (current_length > max_length) {
max_length = current_length;
max_index = current_index;
}
return std::make_pair(max_index, max_length);
}
int main() {
std::vector<std::vector<int>> matrix(N, std::vector<int>(N, 0));
// 从文件中读取矩阵
std::string filename;
std::cout << "请输入包含矩阵的文件名：";
std::cin >> filename;
std::ifstream file(filename);
if (file.is_open()) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
file >> matrix[i][j];
}
}
file.close();
}
else {
std::cout << "无法打开文件！" << std::endl;
return 0;
}
// 计算水平方向上的最长屏障
std::pair<int, int> horizontalBarrier = calculateHorizontalBarrier(matrix);
std::cout << "水平方向上的最长屏障位置：" << horizontalBarrier.first << std::endl;
std::cout << "水平方向上的最长屏障长度：" << horizontalBarrier.second << std::endl;
// 计算竖直方向上的最长屏障
std::pair<int, int> verticalBarrier = calculateVerticalBarrier(matrix);
std::cout << "竖直方向上的最长屏障位置：" << verticalBarrier.first << std::endl;
std::cout << "竖直方向上的最长屏障长度：" << verticalBarrier.second << std::endl;
// 计算正对角方向上的最长屏障
std::pair<int, int> diagonalBarrier = calculateDiagonalBarrier(matrix);
std::cout << "正对角方向上的最长屏障位置：" << diagonalBarrier.first << std::endl;
std::cout << "正对角方向上的最长屏障长度：" << diagonalBarrier.second << std::endl;
// 计算逆对角方向上的最长屏障
std::pair<int, int> inverseDiagonalBarrier = calculateInverseDiagonalBarrier(matrix);
std::cout << "逆对角方向上的最长屏障位置：" << inverseDiagonalBarrier.first << std::endl;
std::cout << "逆对角方向上的最长屏障长度：" << inverseDiagonalBarrier.second << std::endl;
// 判断4个最长屏障是否有共用元素
if (horizontalBarrier.second == verticalBarrier.second &&
horizontalBarrier.second == diagonalBarrier.second && horizontalBarrier.second == inverseDiagonalBarrier.second) {
std::cout << "4个最长屏障有共用元素" << std::endl;
}
else {
std::cout << "4个最长屏障没有共用元素" << std::endl;
}
return 0;
}
基于new bing部分指引作答：
下面是一个使用C++编写的程序，用于读取矩阵并计算水平、垂直、正对角线和逆对角线方向上的最长屏障，并判断它们是否存在共用元素。请注意，此处假设矩阵大小由预定义常量N和M指定。
#include <iostream>
#include <fstream>
#define N 3
#define M 4
void readMatrix(int matrix[N][M], const std::string& fileName) {
std::ifstream inputFile(fileName);
if (inputFile.is_open()) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
inputFile >> matrix[i][j];
}
}
inputFile.close();
} else {
std::cout << "Failed to open file: " << fileName << std::endl;
}
}
void findLongestBarrier(int matrix[N][M], int& startRow, int& startCol, int& length, bool horizontal) {
int maxLength = 0;
int maxLengthStartRow = -1;
int maxLengthStartCol = -1;
for (int i = 0; i < N; i++) {
int currentLength = 0;
for (int j = 0; j < M; j++) {
int row = (horizontal) ? i : j;
int col = (horizontal) ? j : i;
if (matrix[row][col] == 1) {
currentLength++;
if (currentLength > maxLength) {
maxLength = currentLength;
maxLengthStartRow = row - maxLength + 1;
maxLengthStartCol = col - maxLength + 1;
}
} else {
currentLength = 0;
}
}
}
startRow = maxLengthStartRow;
startCol = maxLengthStartCol;
length = maxLength;
}
bool checkOverlap(int matrix[N][M], int row, int col, int length) {
for (int i = row; i < row + length; i++) {
for (int j = col; j < col + length; j++) {
if (matrix[i][j] == 1) {
return true;
}
}
}
return false;
}
int main() {
int matrix[N][M];
// Read matrix from file
std::string fileName;
std::cout << "Enter file name: ";
std::cin >> fileName;
readMatrix(matrix, fileName);
// Calculate longest barriers
int horizontalStartRow, horizontalStartCol, horizontalLength;
findLongestBarrier(matrix, horizontalStartRow, horizontalStartCol, horizontalLength, true);
int verticalStartRow, verticalStartCol, verticalLength;
findLongestBarrier(matrix, verticalStartRow, verticalStartCol, verticalLength, false);
int diagonalStartRow, diagonalStartCol, diagonalLength;
findLongestBarrier(matrix, diagonalStartRow, diagonalStartCol, diagonalLength, true);
int antiDiagonalStartRow, antiDiagonalStartCol, antiDiagonalLength;
findLongestBarrier(matrix, antiDiagonalStartRow, antiDiagonalStartCol, antiDiagonalLength, false);
// Check for overlap
bool overlap = false;
overlap = overlap || checkOverlap(matrix, horizontalStartRow, horizontalStartCol, horizontalLength);
overlap = overlap || checkOverlap(matrix, verticalStartRow, verticalStartCol, verticalLength);
overlap = overlap || checkOverlap(matrix, diagonalStartRow, diagonalStartCol, diagonalLength);
overlap = overlap || checkOverlap(matrix, antiDiagonalStartRow, antiDiagonalStartCol, antiDiagonalLength);
// Output results
std::cout << "Horizontal barrier: Start=(" << horizontalStartRow << ", " << horizontalStartCol
<< "), Length=" << horizontalLength << std::endl;
std::cout << "Vertical barrier: Start=(" << verticalStartRow << ", " << verticalStartCol
<< "), Length=" << verticalLength << std::endl;
std::cout << "Diagonal barrier: Start=(" << diagonalStartRow << ", " << diagonalStartCol
<< "), Length=" << diagonalLength << std::endl;
std::cout << "Anti-diagonal barrier: Start=(" << antiDiagonalStartRow << ", " << antiDiagonalStartCol
<< "), Length=" << antiDiagonalLength << std::endl;
if (overlap) {
std::cout << "The barriers have overlapping elements." << std::endl;
} else {
std::cout << "The barriers do not have overlapping elements." << std::endl;
}
return 0;
}
上述代码假定输入文件中的矩阵大小与预定义常量N和M匹配。在运行代码之前，确保输入文件的格式正确，并且输入的矩阵大小与N和M一致。
以下是一个C++编程示例，实现了你描述的功能。程序首先读取包含矩阵数据的文件，并将其存储在一个二维数组中。然后，程序计算水平、竖直、正对角和逆对角方向上的最长屏障，并判断它们是否有共用元素。
#include <iostream>
#include <fstream>
#include <vector>
#define MATRIX_SIZE 10 // 定义矩阵大小
// 函数声明
void readMatrixFromFile(const std::string& fileName, std::vector<std::vector<int>>& matrix);
std::pair<int, int> findLongestBarrier(const std::vector<std::vector<int>>& matrix, const int direction);
bool checkIfShared(const std::vector<std::vector<int>>& matrix, const std::pair<int, int>& barrier1, const std::pair<int, int>& barrier2);
int main() {
std::string fileName;
std::cout << "请输入包含矩阵数据的文件名：";
std::cin >> fileName;
std::vector<std::vector<int>> matrix;
readMatrixFromFile(fileName, matrix);
std::pair<int, int> horizontalBarrier = findLongestBarrier(matrix, 0);
std::pair<int, int> verticalBarrier = findLongestBarrier(matrix, 1);
std::pair<int, int> diagonalBarrier = findLongestBarrier(matrix, 2);
std::pair<int, int> antiDiagonalBarrier = findLongestBarrier(matrix, 3);
std::cout << "水平方向上的最长屏障：" << horizontalBarrier.first << "，长度：" << horizontalBarrier.second << std::endl;
std::cout << "竖直方向上的最长屏障：" << verticalBarrier.first << "，长度：" << verticalBarrier.second << std::endl;
std::cout << "正对角方向上的最长屏障：" << diagonalBarrier.first << "，长度：" << diagonalBarrier.second << std::endl;
std::cout << "逆对角方向上的最长屏障：" << antiDiagonalBarrier.first << "，长度：" << antiDiagonalBarrier.second << std::endl;
if (checkIfShared(matrix, horizontalBarrier, verticalBarrier))
std::cout << "水平方向上的最长屏障和竖直方向上的最长屏障有共用元素。" << std::endl;
else if (checkIfShared(matrix, horizontalBarrier, diagonalBarrier))
std::cout << "水平方向上的最长屏障和正对角方向上的最长屏障有共用元素。" << std::endl;
else if (checkIfShared(matrix, horizontalBarrier, antiDiagonalBarrier))
std::cout << "水平方向上的最长屏障和逆对角方向上的最长屏障有共用元素。" << std::endl;
else if (checkIfShared(matrix, verticalBarrier, diagonalBarrier))
std::cout << "竖直方向上的最长屏障和正对角方向上的最长屏障有共用元素。" << std::endl;
else if (checkIfShared(matrix, verticalBarrier, antiDiagonalBarrier))
std::cout << "竖直方向上的最长屏障和逆对角方向上的最长屏障有共用元素。" << std::endl;
else if (checkIfShared(matrix, diagonalBarrier, antiDiagonalBarrier))
std::cout << "正对角方向上的最长屏障和逆对角方向上的最长屏障有共用元素。" << std::endl;
else
std::cout << "这4个最长屏障没有共用元素。" << std::endl;
return 0;
}
// 从文件中读取矩阵数据
void readMatrixFromFile(const std::string& fileName, std::vector<std::vector<int>>& matrix) {
std::ifstream file(fileName);
if (file.is_open()) {
matrix.resize(MATRIX_SIZE, std::vector<int>(MATRIX_SIZE));
for (int i = 0; i < MATRIX_SIZE; ++i) {
for (int j = 0; j < MATRIX_SIZE; ++j) {
file >> matrix[i][j];
}
}
file.close();
} else {
std::cerr << "无法打开文件：" << fileName << std::endl;
}
}
// 查找指定方向上的最长屏障
std::pair<int, int> findLongestBarrier(const std::vector<std::vector<int>>& matrix, const int direction) {
int maxBarrierIndex = -1;
int maxBarrierLength = 0;
switch (direction) {
case 0: // 水平方向
for (int i = 0; i < MATRIX_SIZE; ++i) {
int currentBarrierLength = 0;
for (int j = 0; j < MATRIX_SIZE; ++j) {
if (matrix[i][j] == 1)
currentBarrierLength++;
else
currentBarrierLength = 0;
if (currentBarrierLength > maxBarrierLength) {
maxBarrierLength = currentBarrierLength;
maxBarrierIndex = i;
}
}
}
break;
case 1: // 竖直方向
for (int j = 0; j < MATRIX_SIZE; ++j) {
int currentBarrierLength = 0;
for (int i = 0; i < MATRIX_SIZE; ++i) {
if (matrix[i][j] == 1)
currentBarrierLength++;
else
currentBarrierLength = 0;
if (currentBarrierLength > maxBarrierLength) {
maxBarrierLength = currentBarrierLength;
maxBarrierIndex = j;
}
}
}
break;
case 2: // 正对角方向
for (int k = 0; k < MATRIX_SIZE; ++k) {
int i = 0;
int j = k;
int currentBarrierLength = 0;
while (i < MATRIX_SIZE && j < MATRIX_SIZE) {
if (matrix[i][j] == 1)
currentBarrierLength++;
else
currentBarrierLength = 0;
if (currentBarrierLength > maxBarrierLength) {
maxBarrierLength = currentBarrierLength;
maxBarrierIndex = k;
}
i++;
j++;
}
}
break;
case 3: // 逆对角方向
for (int k = 0; k < MATRIX_SIZE; ++k) {
int i
- 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7681553
按照四个输出要求的方向，for循环判断记录最长的长度和元素，先输出前四个。第五个输出用计数法判断一下有没有元素为4就行了。代码逻辑不复杂，行数可能有点多但都属于基础代码，上课稍微认真一点就会的东西。