Question

我正在寻找一种有效的算法，该算法从给定索引的点对角，垂直和水平迭代N×N方阵。

例如，在4x4矩阵中，如果[2][1]是给定索引，算法应该通过索引搜索另一个给定元素的存在：

[0][1], [1][1], [3][1], // Vertically
[2][0], [2][2], [2][3], // Horizontally
[3][0], [1][2], [0][3], // Diagonally (/)
[1][0], [3][2]          // Diagonally (\)

这张照片会让它变得更加清晰：

注意在搜索中指定的索引（[2][1]）未包含。

我设法用C ++编写一个工作解决方案，效率不高：

int Check(int arr[][100], int i, int j, int q, int n)
{
    for (int k = 0; k < n; k++)
        if ((arr[i][k] == q && k != j) || (arr[k][j] == q && k != i))
            return 1;
    //vertical n horizontal

    if ((i - j) >= 0)
    {
        for (int l = i - j, m = 0; l < n; l++)
            if (arr[l][m++] == q && l != i && (m - 1) != j)
                return 1;
    }
    else
    {
        for (int l = j - i, m = 0; l < n; l++)
            if (arr[m++][l] == q && (m - 1) != i&&l != j)
                return 1;
    }
    //  Diagonal (\)

    int l = i, m = j;
    while (1)
    {
        if (l == 0 || m == n - 1)
            break;
        l--;
        m++;
    }

    if (l == 0)
    {
        while (m >= 0)
            if (arr[l++][m--] == q && (l - 1) != i && (m + 1) != j)
                return 1;
    }
    else
    {
        while (l < n)
            if (arr[l++][m--] == q && (l - 1) != i && (m + 1) != j)
                return 1;
    }
    //  Diagonal(/)

    return -1;
}

Check()从元素arr对角线，垂直和水平搜索矩阵arr[i][j]。如果任一方向中存在q，则返回1 else，-1。

如何有效实施上述措施？

任何代码（最好用C / C ++）都会很棒。

Answer 1

您必须简化循环操作，排除对当前单元格的过度检查。只需在当前单元格之前和之后单独行走。

 //horizontal
 for (int k = 0; k < j; k++)
       if (arr[i][k] == q)
           return 1;
 for (int k = j+1; k < n; k++)
       if (arr[i][k] == q)
           return 1;

//main diagonal, case of bottom-left triangle
 dij = i-j;
 if (dij>=0) {
    for (k=0;k<j;k++)
       if (arr[k+dij][k] == q)
           return 1;
    for (k=i+1;k<n;k++)
       if (arr[k][k-dij] == q)
           return 1;
}

对角线，垂直和水平搜索矩阵形成一个点

1 个答案: