0

“用 Java 编写一个方法，如果在棋盘（二维数组）的同一行、列或对角线上有 k 个相邻的符号出现，则返回 true，其中 k 是所需的内联符号数。”

我怎样才能做到这一点？我对如何检查行和列有一个粗略的想法（非常粗略；没有代码，只是想法），但我不知道检查对角线。

编辑：我正在考虑的另一种情况：如何检查任意位置？现在，我只考虑从 (0,0) 开始的事件，但是如果从 (2,3) 到 (2,6) 有一个 3 字符串怎么办？我怎样才能跟踪多次出现？

编辑：检测左对角线（我在下面的评论中发布的问题的粗略代码）：

LeftDiagonal(x, symbol) {
    noOfOccurence = 0;

    for (currentX = (size - 1); currentX >= x; currentX--) {
        if (board[currentX][currentX] == symbol) {
            noOfOccurence++;
        } else {
            break;
        }
    }

    return (noOfOccurence >= k);
}
4

4 回答 4

2

想到的最简单（虽然不是最有效，因为它可能回溯）的解决方案是编写一个递归函数，如以下伪代码

 FindAdjacent(x, y)
       if (matrix[x-1][y-1] == matrix[x][y])
            return 1 + FindAdjacent(x-1,y-1);
       .. Repeat for all 7 other adjacent locations (-1, +0) (+0, -1) (+1, -1) (-1, +1) (+1, +1) (+1, 0) (0, +1)
       else return 1;

该例程将在给定坐标 x,y 的情况下以“blob”的形式返回其周围的符号。
注意：这也意味着对符号进行分组，例如连续 3 个，下面的列中旁边有 1 个。

如果您要为矩阵中的每个位置调用一次，并查看所有递归级别返回后的返回值是否为>= k，那可能会解决您的问题。请记住进行边界检查，这样您就不会检查 matrix[-1][-1] 或任何东西。

于 2012-10-15T01:18:29.410 回答
0

你会运行很多我想象的嵌套循环。不要忘记所有的对角线。

array[1][1] is just below array[0][1] above array[2][1] to the left of array[1][2] to the right of array[1][0] and diagonal to four different points:

diagonal up and to the left is array[0][0]
diagonal up and to the right is array[0][2]
down and to the left is array [2][0]
down and to the right is array[2][2]

[0][0] | [0][1] | [0][2]
[1][0] | [1][1] | [1][2]
[2][0] | [2][1] | [2][2]

如果您绘制很多图表，我认为 array[x][y] 会产生误导。array[row][column] 更好。

于 2012-10-15T01:31:35.000 回答
0 
for(i=0;i<row;i++)
For(j=0;j<column;j++){
current = Arr[row][col];
For(count=0;count<k;count++)
{
If(current==arr[row][col+count])
Flagcol=true
Else
Flagcol=false
}
For(count=0;count<k;count++)
{
If(current==arr[row+count][col])
Flagrow=true
else
Flagrow=false
}
For(count=0;count<k;count++)
{
If(current==arr[row+count][col+count])
Flagdiagnoltrue
Else 
Flagdiagnol=false
}
}
}

一个非常粗略的草稿给出想法..记住一件事你需要检查行+计数/列+计数是否不应该超过行/计数..否则 outofbondsexception..:-D

于 2012-10-15T02:43:21.043 回答
0

首先，不要相信你的“想法”。写出真正的代码以确保您可以进行行和列检查。

这个想法应该是直截了当的：

循环通过棋盘。假设左上角是 [0,0]，然后向右走 ([0,1], [0,2]...) 直到碰到右边界。然后转到下一行。完成，直到你点击右下角的框。

对于每个框，检查是否有 k 个出现 1. 向右，2. 向下，3. 对角线向左向下和 4. 对角线向右向下。

如果发生 4 个中的任何一个，则返回 true，否则，移动到下一个单元格。

例如，这里是一些示例伪代码：

遍历板：

ROWS=8;
COLS=8;
char[ROWS][COLS] board;
k = 3; // occurrence

for (x = 0 to COLS-1) {
  for (y = 0 to ROWS-1) {
    checkRightward(x, y, k);
    // checkDownward(...)
  }
}

样本检查向右：

checkRightward(x,y,k) {
  char symbol = board[y][x];
  noOfOccurence = 0;
  for (currentX = x; currentX  < COLS ; ++currentX) {
    if (board[y][currentX] == symbol) {
      noOfOccurence++;
    } else {
      break; // jump out from the loop
    }
  }

  return (noOfOccurence >= k);
}

您应该不难将这个想法翻译成 Java，并添加其他缺失的检查。

编辑：由于作者似乎并不真正理解我在说什么......所以我对这个想法进行了一些视觉展示：

假设一个 8 x 8 板，它是这样的：

           X
     0 1 2 3 4 5 6 7
  0
  1
  2
  3        * ---->
Y 4      / | \
  5   |/_  |  _\|
  6        V     
  7

在上图中，当前单元格（带星号 * 的位置）的 [x,y] 坐标为 [3,3]。你要做的就是检查

1) 向右：这意味着检查 [3,3]、[4,3]、[5,3].... 是否具有相同的符号

2）向下：这意味着检查 [3,3]、[3,4]、[3,5].... 是否具有相同的符号

3）右对角线：这意味着检查 [3,3], [4,4], [5,5].... 是否具有相同的符号

4) 左对角线：这意味着检查 [3,3], [2,4], [1,5].... 是否具有相同的符号

您从 [0,0] 单元格开始检查，然后 [1,0], [2,0]... 然后 [0,1],[1,1][2,1]... 直到您找到了一个单元格，其中 4 次检查中的任何一个都成功，或者当您点击最后一个单元格时 ([7,7])。

于 2012-10-15T02:22:34.823 回答