C检查二维数组中元素的所有邻居

Question

我一直在想，如果我想检查 C 中二进制数字二维数组中任意元素的所有八个邻居，是否有更聪明的解决方案

我做的是:

伪代码:

//return how many neighbor of an element at x,y equals 1.
int neighbor(int** array, int x, int y)
    if x>WIDTH
        error
    if y>HIEGHT 
        error
    if x==0
        ignore west, nw, sw, and calculate the rest.....
    etc..

这很无聊，有没有更聪明的解决方案？

Answer 1

我使用类似的方法为 Minesweeper Game 中的特定单元格获取 Adjacent Mines。我所做的是，我使用了这样的数组 (MAX_NUMBER_OF_CELLS = 8) :

int offset[MAX_NUMBER_OF_CELLS][2] = {
                                            {-1, -1},
                                            {-1, 0},
                                            {-1, 1},
                                            {0, -1},
                                            {0, 1},
                                            {1, -1},
                                            {1, 0},
                                            {1, 1}
                                         };

考虑到我们正在讨论矩阵中 location 0, 0 处的 CELL。我们将简单地将这些偏移值添加到 CELL 以检查相邻的 CELL 是否是有效的 CELL(即它落在矩阵内)。如果它是 VALID，那么我们将查看它是否包含 1，如果是，则将 sum 增加 1 否则不是。

//rest of the values represent x and y that we are calculating
(-1, -1)           (-1, 0)               (-1, 1)
           -------------------------
 (0, -1)   |(0, 0(This is i and j))|     (0, 1)
           -------------------------
 (1, -1)           (1, 0)                (1, 1)

---

sum = 0;
for (k = 0; k < MAX_NUMBER_OF_CELLS; k++)
{
    indexX = i + offset[k][0];
    indexY = j + offset[k][1];
    if (isValidCell(indexX, indexY, model)) // Here check if new CELL is VALID
                                            // whether indexX >= 0 && indexX < rows
                                            // and indexY >= 0 && indexY < columns
    {
        flag = 1;
        if (arr[indexX][indexY] == 1))
            sum += 1;
    }
}

编辑 1:

这是一个工作示例(C 不是我的语言，尽管我仍然尝试着给你一个想法:-)):

#include <stdio.h>
#include <stdlib.h>

int findAdjacent(int [4][4], int, int, int, int);

int main(void) 
{
    int arr[4][4] = {
        {0, 1, 0, 0},
        {1, 0, 1, 1},
        {0, 1, 0, 0},
        {0, 0, 0, 0}
    };
    int i = 2, j = 2;
    int sum = findAdjacent(arr, i, j, 4, 4);
    printf("Adjacent cells from (%d, %d) with value 1 : %d\n", i, j, sum);
    return EXIT_SUCCESS;
}

int findAdjacent(int arr[4][4], int i, int j, int rows, int columns)
{
    int sum = 0, k = 0;
    int x = -1, y = -1; // Location of the new CELL, which
                        // we will find after adding offsets
                        // to the present value of i and j
    int offset[8][2] = {
        {-1, -1},
        {-1, 0},
        {-1, 1},
        {0, -1},
        {0, 1},
        {1, -1},
        {1, 0},
        {1, 1}
    };
    for (k = 0; k < 8; k++)
    {
        x = i + offset[k][0];
        y = j + offset[k][1];
        if (isValidCell(x, y, rows, columns))
        {
            if (arr[x][y] == 1)
                sum += 1;
        }
    }

    return sum;
}

int isValidCell(int x, int y, int rows, int columns)
{
    if ((x >= 0 && x < rows) && (y >= 0 && y < columns))
        return 1;
    return 0;
}