查找矩阵 NxN 中的所有峰值

Question

我正在尝试创建一个算法，使用简单的方法在 N x N 矩阵中找到 所有峰值。但我在角落、第一行和最后一行以及第一列和最后一列面临一些问题。我正在考虑如下问题：

[ ][c][ ][ ] a is considered a 2d peak
[d][a][e][ ] or a hill iff a >= b,
[ ][b][ ][ ] a >= d, a >=c, a >=e
[ ][ ][ ][ ]

但是，当我需要将角评估为下面的表示时，c 和 d 不存在。我必须评估太多条件才能得到更通用的东西。即，对于下面的a，如果row-1 < 0，我需要检查位置a是否有效，那么我不需要检查以上的任何内容a 并且如果 col-1

[a][e][ ][ ] 
[b][ ][ ][ ] 
[ ][ ][ ][ ] 
[ ][ ][ ][ ]

但是当我们把 a 带到其他角落甚至评估其他位置例如上面示例中的 e 时，我需要证明自己是否 e 位于 row-1 存在的有效位置，以防止评估该位置并得到错误（在上面的示例中，如果e >= the element in row-1，我肯定会得到错误检查。我'考虑到角落、第 0 行和第 n 行以及第 0 和第 n 列，我已经实现了一段代码，但我停下来开始思考如何使它更易读和更简单。

void find_hill(){
    int i, j;
    for(i = 0; i < n; i++){
        for(j = 0; j < n; j++){
            //check corners
            if(i-1 < 0){
                if(j-1 < 0){
                   //check if arr[i][j] >= arr at i,j+1 and i+1,j
                }
                if(j+1 > n-1){
                   //check if arr[i][j] >= arr at i,j-1 and i+1,j 
                }
            }                
        }
    }     
}

我想在这里讨论如何找到解决方案。我应该从哪里开始做一些简单的事情？我想以某种方式使用类似于洪水填充的方法，但它分别填充每个位置，可能它不会工作，因为我最终会遇到同样的问题！

Answer 1

我建议以下技巧：复制第一行和最后一行和列，如下所示：

[ ][a][b][c][ ]
[a][a][b][c][c]
[d][d][e][f][f]
[g][g][h][i][i]
[ ][g][h][i][ ]

然后让你的循环从 1 开始并在 n-1 结束。

Answer 2

在算法范围内，有几种选择。

您可以增加矩阵的大小。在理论上，这是一个完全可以接受的选择，因为它只会增加与矩阵宽度成比例的内存量和计算量。但实际上，如果您使用的是相对较小的矩阵，它可能会将它们的大小增加到 9 倍（如果 1x1 矩阵增加到 3x3）。如果你发现这种不优雅，你会发现很多东西都不优雅，避免这种不优雅的“解决方案”通常也比那些东西更不优雅和麻烦。

另一个选项显然是循环内的条件语句。它在理论上是完美的，因为它根本不会增加内存，只会为你已经在做的每个循环周期添加一个常数......实际上它确实做到了，它使每个循环都需要额外的时间来检查条件，所以无论你处理很多小矩阵，还是更少但更大的矩阵，你都让这段代码的性能变差了。如果该代码曾经或很可能成为许多性能问题的瓶颈或生成器，那么这实际上是最糟糕的选择。如果不太可能是这样，那么这是一个不错的选择，因为它以明确和简洁的方式显示了您的意图。因此，如果它是最好的选择取决于上下文，并且您可以通过使用或不使用此解决方案来引起其他程序员的愤怒，这取决于它是他们只想快速阅读的代码的一部分，还是分析的部分显示对应用程序性能低下负有最大责任。

最后，您可以为所有特殊情况编写单独的代码部分 - 分别检查四个角、四个边和矩阵的其余部分。这不会导致“不必要的”内存使用，并将导致最快的工作代码。不过，与其他两个选项相比，阅读起来会很糟糕。

也就是说，我不是在这里讨论这个故事的软件工程方面。您可以使用各种技术（如 fe）使这些选项中的每一个看起来更好、更具可读性和/或可维护性。在另一个答案选项中已经提到过创建一个 get(x,y) 函数来验证它的输入 - “循环内条件”场景的变体。

Answer 3

这类似于将内核应用于图像，例如 Sobel 过滤器或其他使用滑动窗口方法的过滤器。通常情况下，我会忽略边界，但是当您想检测矩阵边界上的山丘时，您需要识别窗口类型。

如果你不关心内存副本，你可以在嵌套的 for 内创建一个 3x3 的窗口，如果窗口在角落，则用中间的值填充相应的值。也许是这样的

int window[3][3];

for (int i = 0; i < n; ++i)
{
    for (int j = 0; j < n; ++j)
    {
        window[1][1] = arr[i][j];
        window[0][1] = (i - 1 < 0) ? window[1][1] : arr[i-1][j];
        window[2][1] = (i == n - 1) ? window[1][1] : arr[i+1][j];

        window[1][0] = (j - 1 < 0) ? window[1][1] : arr[i][j-1];
        window[1][2] = (j == n - 1) ? window[1][1] : arr[i][j+1];

        // Process window
        // ...
    }
}

Answer 4

void find_hill() {

    int i, j, k, l;
    
    for(i = 0; i < n; i++){
    
        for(j = 0; j < n; j++){
        
            for(k = i-1; k <= i+1; k++) {
                
                for(l = j-1; l <= j+1; l++) {
                    
                    if( k > 0 && k < n && l > 0 && l < n && (i-k)*(j-l) == 0 && arr[i][j] >= arr[k][l] ) {
                        
                        arr[i][j] is a peak;
                    }
                }
            }                
        }
    }     
}

你也可能有这种情况

if( !(k == i && j == l) && k > 0 && k < n && l > 0 && l < n && (i-k)*(j-l) == 0 && arr[i][j] > arr[k][l] )

!(k == i && j == l) 可以让您免于在 9 次中运行 1 次的其余条件，但增加了在 9 次中运行 9 次的权重。

在这 9 次中有 1 次中，您还会执行条件内的代码，因此最好添加 !(k == i && j == l)