701、五子棋算法簡單實現

可以直接看702 第二篇

如上圖是一個五子棋遊戲圖。

輸贏計算算法：
        方式一：沒落下一枚棋子從首行首列開始遍歷每個棋子，如發現棋手贏棋則結束遊戲。
        方式二：每落下一枚棋子，從此棋子開始判斷其，縱-橫-左斜-右斜 四個大方向計算棋手輸贏

兩種方式區別：
        方式一：因爲是遍歷所有棋子則可以計算棋子的->右橫、下縱、左下斜、右下斜四個大方向的一部分即可；但是需要計算每個棋子，會造成大量無效計算

        方式二：根據次落下的棋子判斷其四個大方向，八個小方向，也就是方式一剩餘的部分計算，優勢計算規則複雜點，但是不會造成大量無效計算

代碼實現方式一：

import scala.util.control.Breaks
import scala.util.control.Breaks.{break, breakable}

/**
  * 輸贏規則：按照數組座標從第一行第一個開始遍歷每個棋子的四個方向是否5子相連，
  *           因爲是從上到下遍歷棋子所以這四個方向分別是 右橫-下豎-左下斜-右下斜 這四種情況是否五子相連就能判斷出輸贏
  *
  * 缺點：1.需要遍歷棋盤每個位置
  *       2.沒落下一子需要判斷所有棋子
  *
  * 優化：可以使用稀疏數組解決缺點1，但是稀疏數組保存的棋子需要有序按照從上到下，從左到右，只需要對排序的落子位置遍歷
  *       缺點2無法解決！
  *
  * 缺點2解決方案：每落下一子需要遍歷其4個大方向，橫-豎-左斜-右斜 判斷是否有一個方向五子相連
  *       優點：1.不需要對所有棋子遍歷，只需關注落下的棋子
  *       缺點：1.判斷條件相對複雜
  */
object WuziqiDemo01 {
  def main(args: Array[String]): Unit = {
    println("------------輸贏判斷----------")
    //7. 輸贏判斷
    val rowSize = 11
    val colSize = 11
    val array3 = Array.ofDim[Int](rowSize, colSize)
    array3(0)(0) = 2
    array3(0)(1) = 2
    array3(1)(2) = 1
    array3(1)(3) = 1
    array3(1)(4) = 1
    array3(1)(5) = 1
    array3(1)(6) = 1

    array3(2)(3) = 2
    array3(3)(3) = 2
    array3(4)(3) = 2
    //    array3(5)(3) = 2
    array3(6)(3) = 2
    val res = isSY(array3)
    println("棋手："+res +" 贏了")
  }
  /**
    * 7.判斷棋手輸贏，遍歷數據發現只有四種結果 橫-豎-左斜-右斜 這四種情況，如下數據只要是一種情況就是贏
    * 05	06	07	08	09
    * 05	15	25	35	45
    * 05	14	23	32	41
    * 05	16	27	38	49
    *
    * @param arr
    * @return 返回0：勝負未分；1：白子；2：黑子
    */
    
  def isSY(array: Array[Array[Int]]) = {
    var res = 0
    val outer = new Breaks;
    val inner = new Breaks;
    var bool = false
    //從上到下遍歷每個棋子的右-下-左下斜-右下斜 是否五子相連
    outer.breakable {
      for (i <- 0 until array.length) {
        inner.breakable {
          for (j <- 0 until array(i).length) {
            if (array(i)(j) != 0) {
               bool = dealSY(array, new Node(i, j, array(i)(j))) //一種情況相連，則棋手就勝利了
              if (bool) {
                res = array(i)(j) //返回贏得棋手
                inner.break() //終止兩層循環
              }
            }
          }
        }
        if(bool){
          outer.break()
        }
      }
    }
    res
  }
  //四種情況判斷
  def dealSY(array: Array[Array[Int]], node: Node): Boolean = {
    if (isHeng(array, node) || isShu(array, node) || isZuoxie(array, node) || isYouxie(array, node)) true else false
  }

  /**
    * 判斷橫
    * @param array  數據
    * @param node   當前棋子
    * @return 結果
    */
  def isHeng(array: Array[Array[Int]], node: Node): Boolean = {
    //1. 初始化數據
    val colSize = array(0).length
    var res = true
    //2. 判斷右邊是否還有4列
    if(node.col + 4 > colSize -1){
      return false
    }
    breakable {
      //3. 縱向是否五子相連
      for (i <- 0 to 4) {
        //判斷餘下只要有一列值不相等，則不用進行了
        if (array(node.row)(node.col+i) != node.value) {
          res = false
          break()
        }
      }
    }
    res //4. 返回結果
  }

  //判斷豎
  def isShu(array: Array[Array[Int]], node: Node):Boolean = {
    val rowSize = array.length
    var res = true
    //判斷下邊是否還有4 行
    if(node.row + 4 > rowSize -1){
      return false
    }
    breakable {//縱向是否五子相連
      for (i <- 0 to 4) {
        if (array(node.row+i)(node.col) != node.value) {
          res = false
          break()
        }
      }
    }
    res
  }

  //判斷左下斜
  def isZuoxie(array: Array[Array[Int]], node: Node): Boolean = {
    val rowSize = array.length
    //    val colSize = array(0).length
    var res = true
    //判斷餘下是否還有4行
    if (node.row + 4 > rowSize - 1) {
      return false
    }
    //判斷左邊是否還有4列
    if (node.col - 4 < 0) {
      return false
    }
    breakable {
      for (i <- 0 to 4) {//從當前子開始，左下斜方形判斷五子是否連接
        if (array(node.row + i)(node.col - i) != node.value) {
          res = false
          break()
        }
      }
    }
    res
  }

  //判斷右下斜
  def isYouxie(array: Array[Array[Int]], node: Node): Boolean = {
    val rowSize = array.length
    val colSize = array(0).length
    var res = true
    //判斷餘下是否還有4行
    if (node.row + 4 > rowSize - 1) {
      return false
    }
    //判斷右邊是否還有4列
    if (node.col + 4 > colSize - 1) {
      return false
    }
    breakable {
      for (i <- 0 to 4) { //從當前子開始，右下斜方形判斷五子是否連接
        if (array(node.row + i)(node.col + i) != node.value) {
          res = false
          break()
        }
      }
    }
    res
  }
}