该问题要求您在向内螺旋路径中围绕 4x3 矩阵移动，验证每组两个数字是否可以相加或相减以获得路径中的下一个数字 - 其中每组两个数字的第一个值是前一个操作的结果。

如果这是矩阵：

a b c d
e f g h
i j k l

那么路径是：

a b c d h l k j i e f g h 

算法是：

a +- b = c
c +- d = h
h +- l = k
k +- j = i
i +- e = f
f +- g = h

如果它们都相等，那么它是一个有效的序列。 否则打印"无效序列">

因此，您可以将程序制作成一个巨大的if语句：

if( (a + b == c || a - b == c) &&
    (c + d == h || c - d == h) &&
    (h + l == k || h - l == k) &&
    (k + j == i || k - j == i) &&
    (i + e == f || i - e == f) &&
    (f + g == h || f - g == h) )
{
    // print the path
}
else
{
    // print "invalid sequence"
}

如果你这样做，你不需要任何循环或任何东西。

但就像@macroland说的，您可以将 2D 矩阵转换为 1D 矩阵。 如何做到这一点并不是最明显的事情，因为它不像从上到下，从左到右那么容易，但在你想到一种方法之后，它相对简单。 我能想到的最坚定的前进方法是对所采用的路径进行硬编码，如下所示：

int a[3][4] = {{ 2, 3, 5,  8 },
               { 5, 2, 5, -3 },
               { 7, 0, 7, 10 }};
int b[13]; // the output array
int x[13] = {0,1,2,3,3,3,2,1,0,0,1,2,3};
int y[13] = {0,0,0,0,1,2,2,2,2,1,1,1,1};
for(int i=0;i<13;i++) b[i]=a[y[i]][x[i]];

当然，这取决于您知道它始终是 4x3 矩阵的事实。 如果你这样做，你会得到相当于这个的东西：

int b[13] = { 2, 3, 5, 8, -3, 10, 7, 0, 7, 5, 2, 5, -3 };

然后，您可以轻松创建一个 for 循环，用于检查路径中的每个操作是否正常工作。

如果它并不总是一个 4x3 矩阵，您可以更改代码以动态创建路径而不是硬编码它，以便这种方法可以与任何大小的矩阵一起使用 - 一个巨大的 if 语句方法真的不能。

如果您需要查看是否，我确实有一个完整的解决方案，但您特别要求不包括它。

编辑：

现在已经有一段时间了，这是我制作的完整程序，以防对其他人有帮助：

#include <sstream>
#include <iostream>
int a[3][4] = {{ 2, 3, 5, 8},
               { 5, 2, 5,-3},
               { 7, 0, 7,10}};
int b[13];
void convert_array()
{
    int x[13] = {0,1,2,3,3,3,2,1,0,0,1,2,3};
    int y[13] = {0,0,0,0,1,2,2,2,2,1,1,1,1};
    for(int i=0;i<13;i++) b[i]=a[y[i]][x[i]];
}
int main()
{
    std::stringstream s;
    convert_array();
    s << b[0];
    for(int i=1;i<12;i+=2)
    {
        if(b[i-1]+b[i]==b[i+1])
            s << " + " << b[i] << " = " << b[i+1];
        else if(b[i-1]-b[i]==b[i+1])
            s << " - " << b[i] << " = " << b[i+1];
        else
        {
            std::cout << "invalid sequence" << std::endl;
            break; // return 1;
        }
    }
    std::cout << s.str() << std::endl;
    return 0;
}