C++ C++；向量求和错误

任务：

    #include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>

using namespace std;
int main()
{
    vector< vector<int> > arr(6,vector<int>(6));
    for(int arr_i = 0;arr_i < 6;arr_i++){
       for(int arr_j = 0;arr_j < 6;arr_j++){
          cin >> arr[arr_i][arr_j];
       }
    }
    int maxVal = 0;
    for (int y = 2; y < 6; y++)
    {
        for (int x = 2; x < 6; x++)
        {
            if ( y >=2  && x >=2)
            {
                int vert = y;
                int hori = x;
                int first = arr[vert-2][hori] + arr[vert-2][hori-1] + arr[vert-2][hori-2];
                int second = arr[vert-1][hori-1] ;
                int third = arr[vert][hori] + arr[vert][hori-1] + arr[vert][hori-2];
                int sum = first + second + third;
                if (sum > maxVal)
                    maxVal = sum;
            }
        }
    }
    cout << maxVal;
}

在6x6阵列中，可以构建16个3x3阵列。查找3x3数组的最大和（源：）

例如：

最大的3x3阵列是

2 4 4

020

1 2 4

所以我们打印了19张

我的代码：

    #include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>

using namespace std;
int main()
{
    vector< vector<int> > arr(6,vector<int>(6));
    for(int arr_i = 0;arr_i < 6;arr_i++){
       for(int arr_j = 0;arr_j < 6;arr_j++){
          cin >> arr[arr_i][arr_j];
       }
    }
    int maxVal = 0;
    for (int y = 2; y < 6; y++)
    {
        for (int x = 2; x < 6; x++)
        {
            if ( y >=2  && x >=2)
            {
                int vert = y;
                int hori = x;
                int first = arr[vert-2][hori] + arr[vert-2][hori-1] + arr[vert-2][hori-2];
                int second = arr[vert-1][hori-1] ;
                int third = arr[vert][hori] + arr[vert][hori-1] + arr[vert][hori-2];
                int sum = first + second + third;
                if (sum > maxVal)
                    maxVal = sum;
            }
        }
    }
    cout << maxVal;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
向量arr（6，向量（6））；
对于（int arr_i=0；arr_i<6；arr_i++）{
对于（int arr_j=0；arr_j<6；arr_j++）{
cin>>arr[arr_i][arr_j]；
}
}
int maxVal=0；
对于（int y=2；y<6；y++）
{
对于（int x=2；x<6；x++）
{
如果（y>=2&&x>=2）
{
int vert=y；
int-hori=x；
int first=arr[vert-2][hori]+arr[vert-2][hori-1]+arr[vert-2][hori-2]；
int second=arr[vert-1][hori-1]；
int third=arr[vert][hori]+arr[vert][hori-1]+arr[vert][hori-2]；
整数和=第一+第二+第三；
如果（总和>最大值）
maxVal=总和；
}
}
}
cout提供的链接的问题不是3x3子矩阵，而是沙漏形状：

a b c
  d
e f g

为了获得正确的值，第二行的总和应为：

int second = arr[vert-1][hor-1]

而且，没有必要像评论中提到的那样使用if语句。
这里有一个更干净的代码。从
[1][1]
开始，迭代到
[length-1][length-1][length-1]
。在每次迭代中，计算周围沙漏的总和

另外，请注意，您需要求和沙漏，而不是3x3子阵列

#include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>

using namespace std;
int main()
{

    // user input
    //vector< vector<int> > myVector(6,vector<int>(6));
    //for(int arr_i = 0;arr_i < 6;arr_i++)
    //   for(int arr_j = 0;arr_j < 6;arr_j++)
    //       cin >> myVector[arr_i][arr_j];

    // sample input
    vector<vector<int>> myVector = {
                                        { { 1 },{ 1 },{ 1 },{ 0 },{ 0 },{ 0 } },
                                        { { 0 },{ 1 },{ 0 },{ 0 },{ 0 },{ 0 } },
                                        { { 1 },{ 1 },{ 1 },{ 0 },{ 0 },{ 0 } },
                                        { { 0 },{ 0 },{ 2 },{ 4 },{ 4 },{ 0 } },
                                        { { 0 },{ 0 },{ 0 },{ 2 },{ 0 },{ 0 } },
                                        { { 0 },{ 0 },{ 1 },{ 2 },{ 4 },{ 0 } },
                                    };

    int maxVal = -9999; // start with big negative
    for (int y = 1; y < 5; y++)
    {
        int sum = 0;
        for (int x = 1; x < 5; x++)
        {
            sum = myVector[y - 1][x - 1] + myVector[y - 1][x] + myVector[y - 1][x + 1]; // first row of the hourglass
            sum += myVector[y][x];                                                      // second row
            sum += myVector[y + 1][x - 1] + myVector[y + 1][x] + myVector[y + 1][x + 1];// third row

            if (sum > maxVal)
                maxVal = sum;
        }
    }
    cout << maxVal << endl;

    system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
//用户输入
//向量myVector（6，向量（6））；
//对于（int arr_i=0；arr_i<6；arr_i++）
//对于（int arr_j=0；arr_j<6；arr_j++）
//cin>>myVector[arr_i][arr_j]；
//样本输入
向量myVector={
{ { 1 },{ 1 },{ 1 },{ 0 },{ 0 },{ 0 } },
{ { 0 },{ 1 },{ 0 },{ 0 },{ 0 },{ 0 } },
{ { 1 },{ 1 },{ 1 },{ 0 },{ 0 },{ 0 } },
{ { 0 },{ 0 },{ 2 },{ 4 },{ 4 },{ 0 } },
{ { 0 },{ 0 },{ 0 },{ 2 },{ 0 },{ 0 } },
{ { 0 },{ 0 },{ 1 },{ 2 },{ 4 },{ 0 } },
};
int maxVal=-9999；//从大负数开始
对于（int y=1；y<5；y++）
{
整数和=0；
对于（int x=1；x<5；x++）
{
sum=myVector[y-1][x-1]+myVector[y-1][x]+myVector[y-1][x+1]；//沙漏的第一行
sum+=myVector[y][x]；//第二行
sum+=myVector[y+1][x-1]+myVector[y+1][x]+myVector[y+1][x+1]；//第三行
如果（总和>最大值）
maxVal=总和；
}
}
密码
#包括
#包括
#包括
#包括
使用名称空间std；
int main（）{
int arr[7][7]，和[17]，l=0；
对于（int i=0；i<6；i++）{
对于（int j=0；j<6；j++）{
cin>>arr[i][j]；
}
}
对于（int i=0；i<4；i++）{
对于（int j=0；j<4；j++）{
和[l]=0；
sum[l]=sum[l]+arr[i][j]+arr[i][j+1][j]+arr[i+1][j]+arr[i+1][j+1]+arr[i+1][j+2]+arr[i+2][j]+arr[i+2][j+1]+arr[i+2][j+2]；
l++；
}
}
排序（求和，求和+17）；
不能给我们一个失败的测试用例，以及它给出的答案。这样我们就能更容易地发现问题。问题是它做了它想做的事情吗？测试用例是隐藏的，所以你无法预测输入和输出。
如果（y>=2&&x>=2）
那么为什么要以
int y=0
和
int x=0
开始循环？链接中的问题是沙漏式的，你一次做的太多了。你应该将代码拆分为更简单的函数：一个是求3x3子数组的和，给出它的坐标，另一个是在有效坐标上循环并调用第一个函数。