扫雷怎么统计周围雷的数量？（绝对菜鸟）

Question

我是用二维数组弄得很多个button，然后btn[i][j-1]  btn[i][j]  btn[i][j+1]...（共8个）..像这样把周围的雷数加起来，
但是对于特殊的情况又要特殊的考虑，比如说边缘，第一行，最后一行啦 最边缘上的四个...又要有8个
感觉这样的做法太不明智了，各位大侠是怎样做的？
要是不明白看下面的部分

if(btn[i-1][j-1].getText().equals("*")){
System.out.println("count");
countMine++;
}
if(btn[i-1][j].getText().equals("*")){
countMine++;
}
if(btn[i-1][j+1].getText().equals("*")){
countMine++;
}
if(btn[i][j-1].getText().equals("*")){
countMine++;
}
if(btn[i][j+1].getText().equals("*")){
countMine++;
}
if(btn[i+1][j-1].getText().equals("*")){
countMine++;
}
if(btn[i+1][j].getText().equals("*")){
countMine++;
}
if(btn[i+1][j+1].getText().equals("*")){
countMine++;
}
这还仅仅是周围8个都有，特殊情况怎么办呢？真的要分9次吗？

Answer 1

可以用循环就行啦
for(int m = Math.max(0, i - 1); m < Math.min(btn.length, i + 1); m++)
  for(int n = Math.max(0, j - 1); n < Math.min(btn[m].length, j + 1); n++)
    if(btn[m][n].getText().equals("*"))
      countMine++;

Answer 2

哦，应该是 m < Math.min(btn.length, i + 2) 和n < Math.min(btn[m].length, j + 2); 

Answer 3

对的，就像楼上说的，迷宫问题。
解决迷宫的时候，你是8*8的，可是你要new 10*10的。将最外面的一圈设置成为墙壁。
这样用循环解决的时候就很容易了。
放到扫雷，就是将围墙设置成为无雷，只是用的人看不到罢了，这样写循环是很容易的

Answer 4

原来写的，有兴趣的话可以看一下：import java.util.Random;public class MineTest {    public static void main(String[] args) {
        Mine mine = new Mine(10, 10, 35);
        char[][] mineArray = mine.toArray();
        Mine.printMineArray(mineArray);
    }
}class Mine {    /**
     * 雷阵列
     */
    private char[][] mineArray;    /**
     * 雷的总数
     */
    private int total;    /**
     * 有雷时的标记
     */
    public final static char MINE = '#';    /**
     * 周围无雷时的标记
     */
    public final static char BLANK = '0';    public Mine(int height, int width, int total) {
        if(height * width < total) {
            throw new IllegalArgumentException(total + " is too many, total must be less than or equal to " + (height * width));
        }
        this.total = total;
        init(height, width);
    }    public int getTotal() {
        return total;
    }    public char[][] toArray() {
        return this.mineArray.clone();
    }    /**
     * 输出雷阵列的工具方法
     * @param mineArray 雷阵列
     */
    public static void printMineArray(char[][] mineArray) {
        for(int i = 0; i < mineArray.length; i++) {
            for(int j = 0; j < mineArray[i].length; j++) {
                System.out.printf("%2c", mineArray[i][j]);
            }
            System.out.println();
        }
    }    /**
     * 初始化雷阵列
      * @param height 阵列的行数
      * @param width 阵列的列数
      */
    private void init(int height, int width) {
        mineArray = new char[height][width];
        Random r = new Random();
        int y = 0, x = 0, t = 0;        // 置雷
        while(t < total) {
            y = r.nextInt(height);
            x = r.nextInt(width);
            if (mineArray[y][x] != MINE) {
                pubMine(y, x);
                t++;
            }
        }        // 将空白处置为周围无雷标记
        for (int i = 0, m = mineArray.length; i < m; i++) {
            for (int j = 0, n = mineArray[i].length; j < n; j++) {
                if(mineArray[i][j] == 0) {
                    mineArray[i][j] = BLANK;
                }
            }
        }
    }    /**
     * 置雷，并在九宫周围单元格中置上单元格周围雷的数量
      * @param y 纵坐标
      * @param x 横坐标
      */
    private void pubMine(int y, int x) {
        // 扫描整个九宫
        for(int i = y - 1; i <= y + 1; i++) {
            // 行值在范围之外时忽略
            if(i < 0 || i > mineArray.length - 1) {
                continue;
            }            for(int j = x - 1; j <= x + 1; j++) {
                // 列值在范围之外时忽略
                if(j < 0 || j > mineArray.length - 1 ) {
                    continue;
                }
                // 在九宫中心位置时置雷
                if(i == y && j == x) {
                    mineArray[i][j] = MINE;
                }
                // 如果周围单元格为雷时忽略
                if(mineArray[i][j] == MINE) {
                    continue;
                }                if(mineArray[i][j] == 0) {
                    // 周围单元格为空时，标记为“1”
                    mineArray[i][j] = '1';
                }else{
                    // 周围单元格不为空时，标记为当前数值增加1
                    mineArray[i][j] += 1;
                }
            }
        }
    }
}

Answer 5

8楼正解，只是没有运用迷宫的概念，使得代码看起来有点累，而且貌似只能是正方形的扫雷
我改了下 用了迷宫的边界package csdn;import java.util.Random;public class Mine { private int[][] mineArray; public final static int MINE = -1; public Mine(int x, int y, int total) {
if (x * y < total) {
throw new IllegalArgumentException(total
+ " is too many, total must be less than or equal to "
+ (x * y));
}
mineArray = new int[x+2][y+2];
Random r = new Random();
int xx = 0, yy = 0, t = 0;
while (t < total) {
xx = r.nextInt(x)+1;
yy = r.nextInt(y)+1;
if (mineArray[xx][yy] != MINE) {
mineArray[xx][yy] = MINE;
t++;
}
}
}

public void calculated(){
for (int i = 1; i < (mineArray.length-1); i++) {
for (int j = 1; j < (mineArray[i].length-1); j++) {
if(mineArray[i][j]==MINE){

}
else{
if(mineArray[i-1][j-1]==MINE)
mineArray[i][j]++;
if(mineArray[i-1][j]==MINE)
mineArray[i][j]++;
if(mineArray[i-1][j+1]==MINE)
mineArray[i][j]++;
if(mineArray[i][j-1]==MINE)
mineArray[i][j]++;
if(mineArray[i][j+1]==MINE)
mineArray[i][j]++;
if(mineArray[i+1][j-1]==MINE)
mineArray[i][j]++;
if(mineArray[i+1][j]==MINE)
mineArray[i][j]++;
if(mineArray[i+1][j+1]==MINE)
mineArray[i][j]++;

}
}
}
}

public void printMineArray() {
for (int i = 1; i < (mineArray.length-1); i++) {
for (int j = 1; j < (mineArray[i].length-1); j++) {
if(mineArray[i][j]==MINE)
System.out.print("* ");
else
    System.out.print(mineArray[i][j]+" ");
}
System.out.println();
}
}    public static void main(String[] args) {
        Mine mine = new Mine(10, 20, 35);
        mine.calculated();
        mine.printMineArray();
    }
}