Question

我正在尝试在java中创建一个connect 4程序，但我仍然坚持获胜者检查。我知道我可以制作一个很长的列表if和else if，但我认为循环会更好。我对解决这个问题的任何其他方式持开放态度，但是我一直在看的东西让它看起来最好。我知道如何处理行和列，但我甚至不知道从对角线开始的位置。这就是我到目前为止所做的：

编辑：

 int p1counter = 0;
        int p2counter = 0;
        int r = 1;//x 
        int c = 1;//y
        for(r = 1; r <= 6; r++)
        {
            while(c <= 7)
            {
                if(grid[r][c].equals("_"))
                {
                    c++;
                    p1counter = 0;  p2counter = 0;
                }
                else if(grid[r][c].equals("1"))//player 1 counter
                {
                    c++;
                    p1counter++;
                }
                else if(grid[r][c].equals("2"))//player 2 counter
                {
                    c++;
                    p2counter++;
                }
            }
            if(p1counter >= 4)
            {
                JOptionPane.showMessageDialog(null, "Player 1 is the winner!");  
                done = true;
            }
            else if(p2counter >= 4)
            {
                JOptionPane.showMessageDialog(null, "Player 2 is the winner!");  
                done = true;
            }
            return done;
        }

Answer 1

在类似的情况下，我做了以下事情：

创建一个字符串数组;与行+列+对角线一样多的字符串

在四个可能的方向上遍历网格（这不包括每个可能的对角线，因为对角线必须至少为4长）并在字符串中输入相应的字符：例如0（空），1,2

在字符串数组中搜索1111和2222。

首先组织数据，可以使用内置函数进行比较。更快更清洁。

以下是如何做到的（这是“缓慢而谨慎的方式”）：

class c4check {
    public static void main(String[] args) {
        char grid[][] = {{'e','e','e','e','a','b','a'},
                         {'e','a','b','a','b','b','a'},
                         {'e','b','a','a','b','b','a'},
                         {'e','a','b','b','a','b','b'},
                         {'e','b','a','b','b','a','a'},
                         {'e','a','b','a','b','b','a'}};
        int ii, jj, ri, ci, di;
        String checkGrid[] = new String[25];

        // copy rows:
        for(ri = 0; ri < 6; ri++) {
          String temp = "";
          for(ci = 0; ci < 7; ci++) {
            temp += grid[ri][ci];
          }
          checkGrid[ri] = temp;
        }
        // copy columns:
        for(ci = 0; ci < 7; ci++) {
          String temp = "";
          for(ri = 0; ri < 6; ri++) {
            temp += grid[ri][ci];
          }
          checkGrid[ci + 6] = temp;
        }
        // copy first diagonals:
        for(di = 0; di < 6; di++) {
          String temp = "";
          for(ri = 0; ri < 6; ri++) {
            ci = di - 2;
            ri = 0;
            while(ci < 0) {
              ri++;
              ci++;
            }
            for(; ri < 6; ri++, ci++) {
              if( ci > 6 ) continue;
              temp += grid[ri][ci];
            }
          }
          checkGrid[di+13] = temp;
        }
        // diagonals in the other direction:
        for(di = 0; di < 6; di++) {
          String temp = "";
          for(ri = 0; ri < 6; ri++) {
            ci = 8 - di;
            ri = 0;
            while(ci >  6) {
              ri++;
              ci--;
            }
            for(; ri < 6; ri++, ci--) {
              if( ci < 0 ) continue;
              temp += grid[ri][ci];
            }
          }
          checkGrid[di+19] = temp;
        }
        for(ii = 0; ii < 25; ii++) {
          System.out.println("Checking '" + checkGrid[ii] + "'");
          if (checkGrid[ii].contains("aaaa")) System.out.println("Player A wins!");
          if (checkGrid[ii].contains("bbbb")) System.out.println("Player B wins!");
        }
    }
}

显然，不是将temp复制到数组元素，然后在最后检查，而是每次都可以检查"aaaa"或"bbbb"，并尽快从函数返回当你找到一场比赛时。

此特定代码的输出（具有多个“获胜”组合，因此它不是“真实”情况 - 但它允许我检查所有对角线是否被正确访问）：

Checking 'eeeeaba'
Checking 'eababba'
Checking 'ebaabba'
Checking 'eabbabb'
Checking 'ebabbaa'
Checking 'eababba'
Checking 'eeeeee'
Checking 'eababa'
Checking 'ebabab'
Checking 'eaabba'
Checking 'abbabb'
Checking 'bbbbab'
Player B wins!
Checking 'aaabaa'
Checking 'eaaa'
Checking 'ebbbb'
Player B wins!
Checking 'eaabbb'
Checking 'ebaaaa'
Player A wins!
Checking 'eabba'
Checking 'ebbb'
Checking 'abba'
Checking 'ababb'
Checking 'abbbaa'
Checking 'bbabbe'
Checking 'aaaae'
Player A wins!
Checking 'ebbe'

Answer 2

以下是维持获胜者轨道的方法： -

维护4种类型的套装（水平，垂直，两个对角线）。
每当网格上的点被着色时，检查相同类型的相应邻居，例如。如果网格点（x，y）是彩色的，那么对于水平类型，我们检查（x，y + 1）和（x，y-1）。
找到两个相似的彩色邻居的联合。
如果任何一组的大小等于四，那么你就找到了胜利者。您可以在更新当前颜色的点的邻居时进行检查。

建议：使用Union-Find数据结构来实现良好的时间复杂度（请注意，因为您的集合很小，所以没有它也可以。）

Java for循环：如何检查connect 4程序中的获胜者

2 个答案: