PROSAGA码农传奇-Xedge-Minesweeper大师来自Google Code Jam（2014）资格赛

0# 天线宝宝 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <H2>
    算法
  </H2>
  <P>
    我们先来定义一下
     <code>
      N
    </code>
    ，非矿井单元的数量：
  </p>
   <pre>
    <code>
      N = R * C - M

</code>
  </pre>
  <P>
    一个简单的解决方案就是填补一个区域
     <code>
      N
    </code>
     非矿井单元从上到下逐行。示例
     <code>
      R=5
    </code>
    ，
     <code>
      C=5
    </code>
    ，
     <code>
      M=12
    </code>
    ：
  </p>
   <pre>
    <code>
      c....
.....
...**
*****
*****

</code>
  </pre>
  <P>
    那是：
  </p>
  <UL>
    <LI>
      始终从左上角开始。
    </LI>
    <LI>
      填
       <code>
        N / C
      </code>
       从上到下的非地雷行。
    </LI>
    <LI>
      填写下一行
       <code>
        N % C
      </code>
       从左到右的非地雷。
    </LI>
    <LI>
      用矿井填充其余部分。
    </LI>
  </UL>
  <P>
    只有少数特殊情况你需要关心。
  </p>
  <H3>
    单非矿井
  </H3>
  <P>
    如果
     <code>
      N=1
    </code>
    ，任何配置都是正确的解决方案。
  </p>
  <H3>
    单列或单列
  </H3>
  <P>
    如果
     <code>
      R=1
    </code>
    ，只需填写
     <code>
      N
    </code>
     从左到右的非地雷。如果
     <code>
      C=1
    </code>
    ， 填
     <code>
      N
    </code>
     带有（单个）非矿井的行。
  </p>
  <H3>
    非地雷太少
  </H3>
  <P>
    如果
     <code>
      N
    </code>
     是偶数，它必须是> = 4。
  </p>
  <P>
    如果
     <code>
      N
    </code>
     是奇数，它必须是＆gt; = 9.此外，
     <code>
      R
    </code>
     和
     <code>
      C
    </code>
     必须> = 3。
  </p>
  <P>
    否则没有解决方案。
  </p>
  <H3>
    无法填充前两行
  </H3>
  <P>
    如果
     <code>
      N
    </code>
     是偶数，你不能用非地雷填充至少两行，然后填充前两行
     <code>
      N / 2
    </code>
     非矿。
  </p>
  <P>
    如果
     <code>
      N
    </code>
     很奇怪，你不能用非地雷填充至少两行，用3个非地雷填充第三行，然后填充前两行
     <code>
      (N - 3) / 2
    </code>
     非地雷和第三排有3个非地雷。
  </p>
  <H3>
    单排非最后一排
  </H3>
  <P>
    如果
     <code>
      N % C = 1
    </code>
    ，将最终的非矿井从最后一个完整行移动到下一行。
  </p>
  <P>
    示例
     <code>
      R=5
    </code>
    ，
     <code>
      C=5
    </code>
    ，
     <code>
      M=9
    </code>
    ：
  </p>
   <pre>
    <code>
      c....
.....
....*
..***
*****

</code>
  </pre>
  <H2>
    摘要
  </H2>
  <P>
    可以编写一个实现这些规则的算法，并返回生成的矿区的描述
     <code>
      O(1)
    </code>
    。绘制网格需要
     <code>
      O(R*C)
    </code>
    ， 当然。我还根据Code Jam Judge接受的这些想法在Perl中编写了一个实现。
  </p>
</DIV>

1# 遇见你 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    代码z用注释自我解释。 O（R + C）
  </p>
   <pre>
    <code>
      import java.util.Scanner;
    public class Minesweeper {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            for(int j=0;j<n;j++) {
                int r =sc.nextInt(),
                    c = sc.nextInt(),
                    m=sc.nextInt();
                //handling for only one space.
                if(r*c-m==1) {
                    System.out.println("Case #"+(int)(j+1)+":");
                    String a[][] = new String[r][c];
                    completeFill(a,r-1,c-1,"*");
                    printAll(a, r-1, c-1);
                }
                //handling for 2 rows or cols if num of mines - r*c < 2 not possible.
                //missed here the handling of one mine.
                else if(r<2||c<2) {
                    if(((r*c) - m) <2) {
                        System.out.println("Case #"+(int)(j+1)+":");
                        System.out.println("Impossible");
                    }
                    else {
                        System.out.println("Case #"+(int)(j+1)+":");
                        draw(r,c,m);
                    }
                }
                //for all remaining cases r*c - <4 as the click box needs to be zero to propagate
                else if(((r*c) - m) <4) {
                    System.out.println("Case #"+(int)(j+1)+":");
                    System.out.println("Impossible");
                }
                //edge cases found during execution.
                //row or col =2 and m=1 then not possible.
                //row==3 and col==3 and m==2 not possible.
                else {
                    System.out.println("Case #"+(int)(j+1)+":");
                    if(r==3&&m==2&&c==3|| r==2&&m==1 || c==2&&m==1) {
                        System.out.println("Impossible");
                    }
                    else {
                        draw(r,c,m);
                    }
                }
            }
        }
        /*ALGO : IF m < (r and c) then reduce r or c which ever z max 
         * by two first time then on reduce by factor 1. 
         * Then give the input to filling (squarefill) function which files max one line 
         * with given input. and returns the vals of remaining rows and cols.
         * checking the r,c==2 and r,c==3 edge cases.
         **/
        public static void draw(int r,int c, int m) {
            String a[][] = new String[r][c];
            int norow=r-1,nocol=c-1;
            completeFill(a,norow,nocol,".");
            int startR=0,startC=0;
            int red = 2;
            norow = r;
            nocol = c;
            int row=r,col=c;
            boolean first = true;
            boolean print =true;
            while(m>0&&norow>0&&nocol>0) {
                if(m<norow&&m<nocol) {
                    if(norow>nocol) {
                        norow=norow-red;
                        //startR = startR + red;
                    }
                    else if(norow<nocol){
                        nocol=nocol-red;
                        //startC = startC + red;
                    }
                    else {
                        if(r>c) {
                            norow=norow-red;
                        }
                        else {
                            nocol=nocol-red;
                        }
                    }
                    red=1;
                }
                else {
                    int[] temp = squareFill(a, norow, nocol, startR, startC, m,row,col,first);
                    norow = temp[0];
                    nocol = temp[1];
                    startR =r- temp[0];
                    startC =c -temp[1];
                    row = temp[3];
                    col = temp[4];
                    m = temp[2];
                    red=2;
                    //System.out.println(norow + " "+ nocol+ " "+m);
                    if(norow==3&&nocol==3&&m==2 || norow==2&&m==1 || nocol==2&&m==1) {
                        print =false;
                        System.out.println("Impossible");
                        break;
                    }
                }
                first = false;
            }
            //rectFill(a, 1, r, 1, c);
            if(print)
                printAll(a, r-1, c-1);
        }
        public static void completeFill(String[][] a,int row,int col,String x) {
            for(int i=0;i<=row;i++) {
                for(int j=0;j<=col;j++) {
                    a[i][j] = x;
                }
            }
            a[row][col] = "c";
        }
        public static void printAll(String[][] a,int row,int col) {
            for(int i=0;i<=row;i++) {
                for(int j=0;j<=col;j++) {
                    System.out.print(a[i][j]);
                }
                System.out.println();
            }
        }
        public static int[] squareFill(String[][] a,int norow,int nocol,int startR,int startC,int m,int r, int c, boolean first) {
            if(norow < nocol) {
                int fil = 1;
                m = m - norow;
                for(int i=startR;i<startR+norow;i++) {
                    for(int j=startC;j<startC+fil;j++) {
                        a[i][j] = "*";
                    }
                }
                nocol= nocol-fil;
                c = nocol;
                norow = r;
            }
            else {
                int fil = 1;
                m = m-nocol;
                for(int i=startR;i<startR+fil;i++) {
                    for(int j=startC;j<startC+nocol;j++) {
                        a[i][j] = "*";
                    }
                }
                norow = norow-fil;
                r= norow;
                nocol = c;
            }
            return new int[] {norow,nocol,m,r,c};
        }
    }

</code>
  </pre>
</DIV>

2# SHOU宅大可爱 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <H1>
    前检查
  </H1>
  <H2>
    M =（R * C）-1
  </H2>
  <P>
    用所有地雷填充网格并在任何地方点击。
  </p>
  <H2>
    R == 1 || C == 1
  </H2>
  <P>
    按顺序向左/向右（或向上/向下）填充：点击，非地雷，地雷（例如
     <code>
      c...****
    </code>
    ）。
  </p>
  <H2>
    M ==（R * C） -  2 || M ==（R * C） -  3
  </H2>
  <P>
    不可能
  </p>
  <H1>
    算法
  </H1>
  <P>
    我从一个“空”网格开始（全部
     <code>
      .
    </code>
    s）并将咔嗒声放在角落里（我将使用左上角进行点击，然后从右下角开始填充地雷）。
    <BR/>
    
我们会用的
     <code>
      R1
    </code>
     和
     <code>
      C1
    </code>
     作为我们的“当前”行和列。
  </p>
  <P>
    虽然我们有足够的地雷来填充行或列，但在删除时，不会留下一行或一列（
     <code>
      while((M >= R1 && C1 > 2) || (M >= C1 && R1 > 2))
    </code>
    ），我们“修剪”网格（填充地雷并减少
     <code>
      R1
    </code>
     要么
     <code>
      C1
    </code>
    ）使用最短的一面并移除那么多的地雷。因此，留下6个地雷的4x5将成为剩余2个地雷的4x4。
  </p>
  <UL>
    <LI>
      如果我们以2 x n网格结束，我们将拥有0个地雷（我们已经完成）或者剩下1个地雷（不可能获胜）。
    </LI>
    <LI>
      如果我们最终得到一个3 x 3网格，我们要么有0个地雷（我们已经完成），1个地雷（继续下面），或者2个地雷（不可能获胜）。
    </LI>
    <LI>
      任何其他组合都是可赢的。我们检查一下
       <code>
        M == min(R1,C1)-1
      </code>
      如果是这样的话，我们需要从最短的边缘将一个矿井放入一排或一列，然后用剩余的矿井填充最短的边缘。
    </LI>
  </UL>
  <H1>
    例
  </H1>
  <P>
    我将使用数字显示我使用数字进入网格的顺序，以帮助进行可视化
    <BR/>
     <code>
      R = 7, C = 6, M = 29
    </code>
  </p>
   <pre>
    <code>
      c...42
....42
...742
..6742
555542
333332
111111

</code>
  </pre>
  <P>
    我花了几个不同的尝试来使我的算法正确，但我用PHP编写了我的算法并得到了小和大的正确。
  </p>
</DIV>

3# 求赞有赞必回 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    我也试过这个问题，但由于某种原因没有通过检查。
  </p>
  <P>
    我认为，如果少于（行* cols-4）地雷，它可以解决（3x3矩阵），因为我只需要4个单元用于“c”，其边界为“。”。
  </p>
  <P>
    我的算法如下：
  </p>
  <P>
    的<strong>
      可解？
    </强>
    ：
  </p>
  <OL>
    <LI>
      检查是否有足够的地雷空间（
       <code>
        rows*cols - 4 == maximum mines
      </code>
      ）
    </LI>
    <LI>
      例如rows == 1，cols == 1;然后是行* cols-2
    </LI>
    <LI>
      条件是否可能或不可能
    </LI>
  </醇>
  <P>
    的<strong>
      构建解决方案
    </强>
  </p>
  <OL>
    <LI>
      建立
       <code>
        rows*cols matrix
      </code>
      ，默认值为nil
    </LI>
    <LI>
      去
       <code>
        m[0][0]
      </code>
       并指派
       <code>
        'c'
      </code>
    </LI>
    <LI>
      限定
       <code>
        m[0][0]
      </code>
       周围的环境
       <code>
        '.'
      </code>
    </LI>
    <LI>
      从Matrix右下角循环并分配
       <code>
        '*'
      </code>
       直到地雷结束，然后分配
       <code>
        '.'
      </code>
    </LI>
  </醇>
</DIV>

4# 疯子哥哥 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    我使用回溯搜索，但我只能解决小输入问题。
  </p>
  <P>
    基本上算法从充满了地雷的电路板开始，并尝试以第一次“点击”解决电路板的方式移除地雷。问题是，为了允许“点击”扩展到另一个单元格，扩展将来自另一个必须清除所有其他相邻单元格的单元格。有时，要扩展到另一个单元，您需要移除其他地雷，最终需要的地雷数量少于所需数量。如果算法到达这样的位置，算法将回溯。
  </p>
  <P>
    也许相反的做法更简单。从空板开始，以一种不会阻止初始点击“扩展”的方式添加每个矿井。
  </p>
  <P>
    完整的Python代码如下：
  </p>
   <pre>
    <code>
      directions = [
    [-1, -1], [-1, 0], [-1, 1],
    [0, -1],           [0, 1],
    [1,  -1],  [1, 0],  [1, 1],
]

def solve(R, C, M):
    def neighbors(i, j):
        for di, dj in directions:
            if 0 <= (i + di) < R and 0 <= (j + dj) < C:
                yield (i + di, j + dj)

def neighbors_to_clear(i, j, board):
        return [(ni, nj) for ni, nj in neighbors(i, j) if board[ni][nj] == "*"]

def clear_board(order):
        to_clear = R * C - M - 1
        board = [["*" for _ in range(C)] for _ in range(R)]
        for i, j in order:
            board[i][j] = "."
            for ni, nj in neighbors_to_clear(i, j, board):
                to_clear -= 1
                board[ni][nj] = "."
        return board, to_clear

def search(ci, cj):
        nodes = []
        board = []
        to_clear = 1
        nodes.append((ci, cj, []))
        while nodes and to_clear > 0:
            i, j, order = nodes.pop()
            board, to_clear = clear_board(order)
            neworder = order + [(i, j)]
            if to_clear == 0:
                board[ci][cj] = "c"
                return board
            elif to_clear > 0:
                for ni, nj in neighbors_to_clear(i, j, board):
                    board[ni][nj] = "."
                    nodes.append([ni, nj, neworder])

for i in range(R):
        for j in range(C):
            board = search(i, j)
            if board:
                for row in board:
                    print "".join(row)
                return

print "Impossible"
    return

T = int(raw_input())
for i in range(1, T + 1):
    R, C, M = map(int, raw_input().split(" "))
    print("Case #%d:" % i)
    solve(R, C, M)

</code>
  </pre>
</DIV>

5# 浮华丶 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    可以找到解决方案
    <a href="https://code.google.com/codejam/contest/2974486/dashboard#s=a&a=2" rel="nofollow">
      这里
    </A>
    。以下页面的内容。
  </p>
  <BLOCKQUOTE>
    <P>
      有许多方法可以生成有效的矿井配置。在这
  分析，我们尝试枚举所有可能的情况并尝试生成一个
  每种情况的有效配置（如果存在）。之后，有了
  一些见解，我们提供了一种更容易实现的算法来生成
  有效的矿井配置（如果存在）。
    </p>
    <P>
      列举所有可能的案例
    </p>
    <P>
      我们首先检查一些琐碎的案例：
    </p>
    <P>
      如果只有一个空单元格，那么我们就可以填充所有单元格
  除了您单击的单元格以外的地雷。如果R = 1或C = 1，那么地雷
  可以分别从左到右或从上到下放置
  分别点击最右边或最底部的单元格。如果
  董事会不在上述两个小案件中，这意味着董事会已经处于
  至少2 x 2尺寸。然后，我们可以手动检查：
    </p>
    <P>
      如果空单元格的数量是2或3，则不可能有空单元格
  有效配置。如果R = 2或C = 2，则存在有效配置
  只有当M是偶数时。例如，如果R = 2，C = 7且M = 5，则为
  因为M很奇怪所以不可能。但是，如果M = 6，我们可以放置地雷
  在电路板的左侧部分，然后单击右下角，如
  这个：
              
      的<strong>
        * ....
              *
      </强>
      ... c如果电路板不属于上述任何一种情况，则表示电路板尺寸至少为3 x 3。在这种情况下，我们可以永远
  如果空单元的数量更大，则找到有效的矿井配置
  这是一种方法：
    </p>
    <P>
      如果空单元的数量等于或大于3 * C，那么
  地雷可以从上到下逐行放置。如果
  剩余的地雷数量可以完全填满该行或小于C
   -  2然后在那一排从左到右放置地雷。否则，剩余的地雷数量正好是C  -  1，将最后一个地雷放入
  下一行。例如：
              ****** ******
              *****。 **** ..
              ......  - ＆gt; * .....
              ...... ......
              ..... c ..... c如果空单元的数量小于3 * C但至少为9，我们首先用地雷填充所有行
  最后3行。对于最后3行，我们填补剩余的地雷
  从最左侧列开始逐列。如果剩下的地雷上
  最后一列是两列，然后最后一列必须放在下一列。
  例如：
              ****** ******
              
      的<strong>
        ....  - ＆gt; *
      </强>
      ...
              ** .... * .....
              * .... c * .... c现在，我们最多留下9个空单元，它们位于右下方的3 x 3平方单元格中
  角。在这种情况下，我们可以手动检查，如果空的数量
  细胞是5或7，不可能有一个有效的矿井配置。
  否则，我们可以为每个数字硬编码有效配置
  3 x 3平方细胞中的空细胞。
    </p>
    <P>
      叹息......这是很多案例要涵盖的！我们如何说服自己
  当我们编写解决方案时，我们不会错过任何一个角落案例？
    </p>
    <P>
      蛮力方法
    </p>
    <P>
      对于小输入，电路板尺寸最多为5 x 5.我们可以检查所有
  （25选择M）可能的矿井配置并找到一个有效的矿井配置
  （即，单击配置中的空单元格会显示所有其他单元格
  空细胞）。为了检查矿井配置是否有效，我们可以
  运行洪水填充算法（或简单的呼吸优先搜索）
  单击空单元格并验证是否可以访问所有其他空单元格
  （即，它们在一个连接的组件中）。请注意，我们也应该
  检查所有可能的点击位置。这种蛮力方法很快
  足够小的输入。
    </p>
    <P>
      蛮力方法可用于检查（对于R的小值，
  C，M）我们的枚举策略中是否存在假阴性
  以上。当存在有效的矿时，会发现假阴性
  配置，但上面的枚举策略产生不可能。
  一旦我们确信我们的枚举策略不会产生
  任何假阴性，我们都可以用它来解决大输入问题。
    </p>
    <P>
      一种更容易实现的方法
    </p>
    <P>
      在使用了几个有效的矿井配置后
  上面的枚举策略，你可能会注意到一个模式：在一个有效的矿井中
  在配置中，特定行中的地雷数量始终相等
  要么大于它下面和所有的行的地雷数量
  地雷连续左对齐。有了这种洞察力，我们就可以实现了
  更简单的回溯算法，从顶部逐行放置地雷
  在我们继续填写的时候，我们的地雷数量会增加
  如果当前行的配置是下一行并修剪
  无效（可以通过单击右下角的单元格来检查）。这个
  修剪回溯可以处理最多50 x 50大小的板
  合理的时间并且更容易实施（即，不需要
  列举角落/棘手案例）。
    </p>
    <P>
      如果比赛时间较短，我们可能没有足够的时间
  枚举所有可能的情况。在这种情况下，投注
  回溯算法（或任何其他更容易的算法）
  实施）可能是一个好主意。找到这样的算法是一门艺术:)。
    </p>
  </BLOCKQUOTE>
</DIV>

6# 银环蛇 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    我解决这个问题的方法如下：
  </p>
  <UL>
    <LI>
      对于1x1网格，M必须为零，否则不可能
    </LI>
    <LI>
      对于Rx1或1xC网格，我们需要M <= R * C  -  2（在最后一个单元格上放置'c'，旁边有一个空单元格）
    </LI>
    <LI>
      对于RxC网格，我们需要M <= R * C  -  4（在拐角处放置'c'，其周围有3个空单元）
    </LI>
  </UL>
  <P>
    综上所述，
     <code>
      c
    </code>
     无论如何都会在它旁边放置非地雷单元，否则它是不可能的。这个解决方案对我来说很有意义，我已经根据他们的样本和小输入检查了输出，但是它没有被接受。
  </p>
  <P>
    这是我的代码：
  </p>
   <pre>
    <code>
      import sys

fname = sys.argv[1]

handler = open(fname, "r")
lines = [line.strip() for line in handler]

testcases_count = int(lines.pop(0))

def generate_config(R, C, M):
    mines = M

config = []
    for row in range(1, R+1):
        if mines >= C:
            if row >= R - 1:
                config.append(''.join(['*' * (C - 2), '.' * 2]))
                mines = mines - C + 2
            else:
                config.append(''.join('*' * C))
                mines = mines - C
        elif mines > 0:
            if row == R - 1 and mines >= C - 2:
                partial_mines = min(mines, C - 2)
                config.append(''.join(['*' * partial_mines, '.' * (C - partial_mines)]))
                mines = mines - partial_mines
            else:
                config.append(''.join(['*' * mines, '.' * (C - mines)]))
                mines = 0
        else:
            config.append(''.join('.' * C))

# click the last empty cell
    config[-1] = ''.join([config[-1][:-1], 'c'])

return config

for case in range(testcases_count):
    R, C, M = map(int, lines.pop(0).split(' '))

# for a 1x1 grid, M has to be zero
    # for a Rx1 or 1xC grid, we must have M <= # of cells - 2
    # for others, we need at least 4 empty cells
    config_possible = (R == 1 and C == 1 and M==0) or ((R == 1 or C == 1) and M <= R * C - 2) or (R > 1 and C > 1 and M <= R * C - 4)

config = generate_config(R, C, M) if config_possible else None

print "Case #%d:" % (case+1)
    if config:
        for line in config: print line
    else:
        print "Impossible"

handler.close()

</code>
  </pre>
  <P>
    它对网站上的样本以及它们提供的小输入效果非常好，但看起来我错过了一些东西。
  </p>
  <P>
    以下是样本的输出：
  </p>
   <pre>
    <code>
      Case #1:
Impossible
Case #2:
*
.
c
Case #3:
Impossible
Case #4:
***....
.......
.......
......c
Case #5:
**********
**********
**********
**********
**********
**********
**********
**********
**........
.........c

</code>
  </pre>
  <P>
    的<strong>
      更新：
    </强>
     阅读vinaykumar的社论，我理解我的解决方案有什么问题。扫雷的基本规则，我应该涵盖，几乎。
  </p>
</DIV>

7# =_= | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  <P>
    我把它分成两个初始特殊情况，然后有一个通用算法。 tl; dr版本是从左上角构建一个正方形的空格。与其他答案类似，但特殊情况较少。
  </p>
  <H2>
    特别案例
  </H2>
  <H3>
    情况1
  </H3>
  <P>
    只有1个空格。只需单击左上角即可完成。
  </p>
  <H3>
    案例2
  </H3>
  <P>
    2或3个空格，网格不是Rx1或1xC。这是不可能的，所以我们很早就失败了。
  </p>
  <H2>
    算法
  </H2>
  <P>
    始终单击左上角。从左上方的2x2空白方块开始（我们至少有4个空白）。现在我们需要添加剩余的空白。然后我们沿着一个边缘扩展正方形，然后是另一个边缘，直到我们没有空格。
  </p>
  <P>
    消隐顺序示例：
  </p>
   <pre>
    <code>
      C  2  6 12
1  3  7 13
4  5  8 14
9 10 11 15

</code>
  </pre>
  <H3>
    不可能的案例
  </H3>
  <P>
    请注意，在开始新边时，我们必须至少放置两个空格才能使其有效。因此，如果我们只有一个空格，那么这必须是无效的（除非我们的边长度为1）。我的逻辑看起来像这样：
  </p>
   <pre>
    <code>
      if maxEdgeLength > 1 and remainingBlanks == 1:
    print('Impossible')
    return

</code>
  </pre>
  <P>
    但是，我们可能已经离开了最后一个边缘的末端，这将给我们现在两个空白。当然，如果最后一个边缘超过2个空白，我们只能留下最后一个空白！
  </p>
  <P>
    我对这个特例的逻辑看起来像这样：
  </p>
   <pre>
    <code>
      if remainingBlanks == 1 and lastEdgeSize > 2:
    mineMatrix[lastBlank] = '*'
    blanks += 1

</code>
  </pre>
</DIV>