package tictactoe;

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Random;

/**
 * 三目並べ
 */
public class Tictactoe {
	static Board board; // 盤
    static int comLevel[] = {-1, -1};
        /* コンピュータのレベル
           -1 : 人間が打つ
            0 : 合法手から完全ランダム
            1 : 一手勝ちがあればそこに打ち、無ければランダム
            2 : 一手勝ちがあればそこに打ち、無ければ二手負けしない手からランダム
            3 : 指定した手数先読みする
        */

    public static void main (String args[]) {
        setComLevel();
        board = new Board();
        board.show();
        while (true) {
            // ○番
            if (comLevel[0] == -1) board.player(); else board.com (comLevel[0]);
            board.show();
            if (board.doesWin()) {     // ライン達成による○勝ち
                System.out.println ("○の勝ちです");
                break;
            } else if (board.resign) { // 投了による×勝ち
                System.out.println ("×の勝ちです");
                break;
            } else if (board.emptySquares == 0) {
                System.out.println ("引き分けです");
                break;
            }
            board.nextTurn();
            // ×番
            if (comLevel[1] == -1) board.player(); else board.com (comLevel[1]);
            board.show();
            if (board.doesWin()) {     // ライン達成による×勝ち
                System.out.println ("×の勝ちです");
                break;
            } else if (board.resign) { // 投了による○勝ち
                System.out.println ("○の勝ちです");
                break;
            } else if (board.emptySquares == 0) {    // 引き分けになるのは9手目なので、この判定がtrueになることは無い
                System.out.println ("引き分けです");
                break;
            }
            board.nextTurn();
        }
    }

    /**
     * COMのレベルを決定する
     */
    static void setComLevel() {
        Scanner keyBoardScanner = new Scanner(System.in);
        System.out.print ("○はCOMが持ちますか？ (Y/N) ");
        String inputString = keyBoardScanner.next();
        if (inputString.equals ("Y") || inputString.equals ("y")) {
            while (true) { // 適切な値が選択されるまでループ
                System.out.print ("COMのレベルは？ (0～9) ");
                inputString = keyBoardScanner.next();
                try {
                    comLevel[0] = Integer.parseInt (inputString);
                } catch (NumberFormatException e) { // 整数値以外が入力された場合
                    System.out.println ("0～9を入力してください");
                    continue;
                }
                if (comLevel[0] <0 || 9<comLevel[0]) {
                    System.out.println ("0～9を入力してください");
                    continue;
                }
                break;
            }
        }
        System.out.print ("×はCOMが持ちますか？ (Y/N) ");
        inputString = keyBoardScanner.next();
        if (inputString.equals ("Y") || inputString.equals ("y")) {
            while (true) { // 適切な値が選択されるまでループ
                System.out.print ("COMのレベルは？ (0～9) ");
                inputString = keyBoardScanner.next();
                try {
                    comLevel[1] = Integer.parseInt (inputString);
                } catch (NumberFormatException e) { // 整数値以外が入力された場合
                    System.out.println ("0～9を入力してください");
                    continue;
                }
                if (comLevel[1] <0 || 9<comLevel[1]) {
                    System.out.println ("0～9を入力してください");
                    continue;
                }
                break;
            }
        }
    }
}

/**
 * 三目並べの盤面を管理するクラス
 */
class Board {
    int board[];           // 盤面
    /*
      盤面は一次元配列で表現している
      各升との対応は以下の通りテンキー配置である
        ┌─┬─┬─┐
        │７│８│９│
        ├─┼─┼─┤
        │４│５│６│
        ├─┼─┼─┤
        │１│２│３│
        └─┴─┴─┘
     */
    int turn;              // 手番 1なら○番、-1なら×番
    int value;             // 局面の評価値 高いほど○有利な局面
    int maxLineValue;      // 最も高いライン評価値 3なら○勝ち、2なら○リーチ
    int minLineValue;      // 最も低いライン評価値 -3なら×勝ち、-2なら×リーチ
    boolean resign;        // 投了した
    int emptySquares;      // 空升の数
    int previousPlace;     // 直前に打った石の位置
    Random rnd;            // 乱数発生用
    static final int NOUGHT = 1;                 // ○
    static final int CROSS = -1;                 // ×
    static final int EMPTY = 0;                  // 空白
    static final int BORDER = Integer.MAX_VALUE; // 盤外
    static final int SQUAREVALUE[] = {0,         // 各升目に付加する価値
                                      3, 2, 3,   // 中央、角、辺の順に価値が高い
                                      2, 4, 2,
                                      3, 2, 3,
                                      0};
    static final boolean DEBUG = true; // デバグ用 trueにすると実行中に盤面の評価値等のデータを表示する

    /**
     * コンストラクタ
     * 初期盤面を作成する
     */
    Board() {
        board = new int[11];   // オセロは9升だが、その前後も処理によっては必要かもしれないのでサイズ11で定義
        board[0] = BORDER;     // board[0]は盤外扱い
        for (int i=1; i<=9; ++i) board[i] = EMPTY; // 升目を空白に
        board[10] = BORDER;    // board[10]も盤外扱い
        turn = NOUGHT;         // 最初は○番
        value = 0;             // 初期状態では評価値は0
        maxLineValue = 0;
        minLineValue = 0;
        resign = false;        // 初期状態では未投了
        emptySquares = 9;      // 初期状態では空升は9
        previousPlace = 0;     // 初期状態では直前の手は無い
        long seed = System.currentTimeMillis(); // 現在時刻から乱数の種を生成
        rnd = new Random (seed); // 乱数発生用
    }


    /**
     * 盤面を表示する
     */
    void show() {
        System.out.println ("┌─┬─┬─┐");
        System.out.println ("│" + square (7) + "│" +  square (8) + "│" + square (9) + "│");
        System.out.println ("├─┼─┼─┤");
        System.out.println ("│" + square (4) + "│" +  square (5) + "│" + square (6) + "│");
        System.out.println ("├─┼─┼─┤");
        System.out.println ("│" + square (1) + "│" +  square (2) + "│" + square (3) + "│");
        System.out.println ("└─┴─┴─┘");
    }

    /**
     * 盤の升目の文字列表現を返す
     */
    private String square (int i) {
        switch (board [i]) {
        case NOUGHT:
            return "○";
        case CROSS : 
            return "×";
        case EMPTY : 
            return "　";
        default : // 正常な動作をしていた場合ここに処理が移ることは無い
            return "？";
        }
    }

    /**
     * ライン評価値を計算する
     * 縦横斜めの各ラインの評価値を求め、その最大値と最小値を計算する
     * maxLineValueが3なら○勝ち、2なら○リーチ
     * minLineValueが-3なら×勝ち、-2なら×リーチ
     */
    private void computeLineValue() {
        maxLineValue = -3;
        minLineValue = 3;
        int lineValue;
        lineValue = board[1]+board[2]+board[3];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[4]+board[5]+board[6];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[7]+board[8]+board[9];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[1]+board[4]+board[7];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[2]+board[5]+board[8];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[3]+board[6]+board[9];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[1]+board[5]+board[9];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
        lineValue = board[3]+board[5]+board[7];
        if (lineValue > maxLineValue) maxLineValue = lineValue;
        if (lineValue < minLineValue) minLineValue = lineValue;
    }

    /**
     * 局面の評価値を計算する
     * 先読みは行わず、現在の盤面のみで評価値を決定する
     * この部分を変更することによりCOMの戦略が変わる
     * @return int : 盤面の評価値
     */
    private int computeValue() {
        computeLineValue();
        if (maxLineValue == 3)                             // ○が3つ並んでいる場合
            value = Integer.MAX_VALUE;                     // ○勝ち
        else if (minLineValue == -3)                       // ×が3つ並んでいる場合
            value = Integer.MIN_VALUE;                     // ×勝ち
        else if ((maxLineValue == 2) && (turn == NOUGHT))  // ○リーチかつ○番の場合
            value = Integer.MAX_VALUE;                     // 次の手で○勝ち
        else if ((minLineValue == -2) && (turn == CROSS))  // ×リーチかつ×番の場合
            value = Integer.MIN_VALUE;                     // 次の手で×勝ち
        else if (emptySquares == 0)                        // 勝敗が決しないまま升が全て埋まったとき
            value = 0;                                     // 引き分け
        else {
            value = 0;
            for (int i=1; i<=9; ++i) // 各升に付加した評価値を合計する
                value += board[i] * SQUAREVALUE[i];
            if (maxLineValue == 2) value += 2;  // ○リーチなら評価値を上げる
            if (minLineValue == -2) value -= 2; // ×リーチなら評価値を下げる
        }
        return value;
    }

    /**
     * 局面の評価値を計算する
     * 指定した手数先まで再帰的に先読みし、min-max法で評価値を決定する
     * @param int depth : 先読みする手数
     * @return int : 盤面の評価値
     */
    private int computeValue (int depth) {
        if (depth > emptySquares) depth = emptySquares; // 手数の上限は空升数なので、先読み手数もそれに合わせる
        if (depth == 0) // 先読み手数が0の場合は先読みせずに現在の盤面の評価値を返す 
            return computeValue(); 

        int nextValue = 0; // 次の手を打った後の盤面の評価値

        /* 着手可能手のリストを作成する */
        ArrayList<Board> nextBoardList = new ArrayList();
        Board nextBoard;
        /*
         着手可能手を打った後の盤面を生成し、評価値で昇順になるようにリストに挿入する
         */
        for (int i=1; i<=9; ++i) { // 各升に対して着手可能手の生成を行う
            if (board[i] == EMPTY) {        // 空升なら着手可能
                boolean adden = false;
                nextBoard = nextBoard (i);     // その升に打った後の盤面を生成
                nextValue = nextBoard.computeValue(); // 評価値(先読み無し)を計算
                for (int j=0; j<nextBoardList.size(); ++j) { // 評価値で昇順になるようにリストに挿入する
                    if (nextValue < nextBoardList.get(j).value) {
                        nextBoardList.add (j, nextBoard);
                        adden = true;
                        break;
                    }
                }
                if (!adden) nextBoardList.add (nextBoard); // リストの末尾に加える
            }
        }

        if (turn == NOUGHT) { // ○番の場合
            nextBoard = nextBoardList.get(nextBoardList.size()-1); // 最も評価値の高い手を取り出す
            if (nextBoard.value == Integer.MAX_VALUE) { // 必勝手発見
                value = Integer.MAX_VALUE;
            } else if (nextBoard.value == Integer.MIN_VALUE) { // どの手を打っても負け確定
                value = Integer.MIN_VALUE;
            } else {
                while (true) {
                    if (nextBoardList.get(0).value == Integer.MIN_VALUE) {
                        nextBoardList.remove(0); // 負け確定の手は取り除く
                    } else break;
                }

                /* 各有効手に対してそれを着手後の盤面に対して再帰的に評価値を求める */
                /* 着手後の盤面の評価値のうち、最も評価値の高いものを現在の盤面の評価値とする */
                value = Integer.MIN_VALUE;
                for (int i=nextBoardList.size()-1; i>=0; --i) { // 評価値の高そうな手から順に探す
                    nextBoard = nextBoardList.get(i);
                    nextValue = nextBoard.computeValue (depth-1); // 1手進めて再帰
                    if (value < nextValue) value = nextValue;
                    if (value == Integer.MAX_VALUE) // 必勝手発見
                        break; // これ以上の評価値計算は不要なのでループから脱出
                }
            }
        } else { // ×番の場合
            nextBoard = nextBoardList.get(0); // 最も評価値の低い手を取り出す
            if (nextBoard.value == Integer.MIN_VALUE) { // 必勝手発見
                value = Integer.MIN_VALUE;
            } else if (nextBoard.value == Integer.MAX_VALUE) { // どの手を打っても負け確定
                value = Integer.MAX_VALUE;
            } else {
                    while (true) {
                    if (nextBoardList.get(nextBoardList.size()-1).value == Integer.MAX_VALUE) {
                        nextBoardList.remove(nextBoardList.size()-1); // 負け確定の手は取り除く
                    } else break;
                }

                /* 各有効手に対してそれを着手後の盤面に対して再帰的に評価値を求める */
                /* 着手後の盤面の評価値のうち、最も評価値の低いものを現在の盤面の評価値とする */
                nextValue = Integer.MAX_VALUE;
                for (int i=0; i<nextBoardList.size(); ++i) { // 評価値の低そうな手から順に探す
                    nextBoard = nextBoardList.get(i);
                    nextValue = nextBoard.computeValue (depth-1); // 1手進めて再帰
                    if (value > nextValue) value = nextValue;
                    if (value == Integer.MIN_VALUE) // 必勝手発見
                        break; // これ以上の評価値計算は不要なのでループから脱出
                }
            }
        }
        return value;
    }

    /**
     * 人間が一手打つ
     */
    void player () {
        int place; // 打つ位置
        Scanner keyBoardScanner = new Scanner(System.in);
        if (turn == NOUGHT) System.out.println ("○番です"); else System.out.println ("×番です");
        while (true) { // 適切な位置が選択されるまでループ
            System.out.print ("打つ位置(1-9)を選んでください(0=投了): ");
            String inputString = keyBoardScanner.next();
            try {
                place = Integer.parseInt (inputString);
            } catch (NumberFormatException e) { // 整数値以外が入力された場合
                System.out.println ("1～9を入力してください");
                continue;
            }
            if (place <0 || 9<place) {
                System.out.println ("1～9を入力してください");
                continue;
            }
            if (place == 0) {
                resign = true; // 0は投了
                break;
            }
            if (board[place] != EMPTY) {
                System.out.println ("その位置には置けません");
                continue;
            }
            break;
        }
        setStone (place);
    }

    /**
     * COMが一手打つ
     * まず着手可能手のリストを作成し、その中から最も評価値の高いor低い手を選択する
     * @param level : COMのレベル
     */
    void com (int comLevel) {
        /*
         着手可能手のリストを作成する
         番兵として、リストの先頭には×で埋めた盤面を、末尾には○で埋めた盤面を加える
         */
        ArrayList<Board> nextBoardList = new ArrayList();
        Board nextBoard;
        /*
         着手可能手を打った後の盤面を生成し、評価値で昇順になるようにリストに挿入する
         */
        for (int i=1; i<=9; ++i) { // 各升に対して着手可能手の生成を行う
            if (board[i] == EMPTY) {        // 空升なら着手可能
                boolean adden = false;
                nextBoard = nextBoard (i);     // その升に打った後の盤面を生成
                int nextValue = nextBoard.computeValue(); // 評価値(先読み無し)を計算
                for (int j=0; j<nextBoardList.size(); ++j) { // 評価値で昇順になるようにリストに挿入する
                    if (nextValue < nextBoardList.get(j).value) {
                        nextBoardList.add (j, nextBoard);
                        adden = true;
                        break;
                    }
                }
                if (!adden) nextBoardList.add (nextBoard); // リストの末尾に加える
            }
        }
        if (DEBUG) { // デバグ情報(先読み無しの評価値)の表示
            for (int i=0; i<nextBoardList.size(); ++i)
                System.out.println ("着手:" + nextBoardList.get(i).previousPlace + " 評価値:" + nextBoardList.get(i).value);
        }

        /* COMのレベルに応じて次の手を探索する */
        int r, r1, r2; // 乱数用
        switch (comLevel) {
        case 0 : // レベル0 : 完全ランダム
            r = rnd.nextInt (nextBoardList.size());
            nextBoard = nextBoardList.get (r);
            break;
        case 1 : // レベル1 : 一手勝ちがあればそれを打ち、無ければランダム
            if (turn == NOUGHT) { // ○番の場合
                nextBoard = nextBoardList.get(nextBoardList.size()-1); // 最も評価値の高い手を取り出す
                if (nextBoard.value == Integer.MAX_VALUE) { // 必勝手発見
                } else {
                    r1 = rnd.nextInt (nextBoardList.size());
                    r2 = rnd.nextInt (nextBoardList.size());
                    if (r1>r2) r=r1; else r=r2; // 一応ランダムだが、評価値の高い手が選ばれる確率を高くする
                    nextBoard = nextBoardList.get (r);
                }
            } else { // ×番の場合
                nextBoard = nextBoardList.get(0); // 最も評価値の低い手を取り出す
                if (nextBoard.value == Integer.MIN_VALUE) { // 必勝手発見
                } else {
                    r1 = rnd.nextInt (nextBoardList.size());
                    r2 = rnd.nextInt (nextBoardList.size());
                    if (r1<r2) r=r1; else r=r2; // 一応ランダムだが、評価値の低い手が選ばれる確率を高くする
                    nextBoard = nextBoardList.get (r);
                }
            }
            break;
        case 2 : // レベル2 : 一手勝ちがあればそれを打ち、無ければ二手負けにならない中からランダム
            if (turn == NOUGHT) { // ○番の場合
                nextBoard = nextBoardList.get(nextBoardList.size()-1); // 最も評価値の高い手を取り出す
                if (nextBoard.value == Integer.MAX_VALUE) { // 必勝手発見
                } else if (nextBoard.value == Integer.MIN_VALUE) { // どの手を打っても負け確定
                } else {
                    while (true) {
                        if (nextBoardList.get(0).value == Integer.MIN_VALUE) {
                            nextBoardList.remove(0); // 負け確定の手は取り除く
                        } else break;
                    }
                    r1 = rnd.nextInt (nextBoardList.size());
                    r2 = rnd.nextInt (nextBoardList.size());
                    if (r1>r2) r=r1; else r=r2; // 一応ランダムだが、評価値の高い手が選ばれる確率を高くする
                    nextBoard = nextBoardList.get (r);
                }
            } else { // ×番の場合
                nextBoard = nextBoardList.get(0); // 最も評価値の低い手を取り出す
                if (nextBoard.value == Integer.MIN_VALUE) { // 必勝手発見
                } else if (nextBoard.value == Integer.MAX_VALUE) { // どの手を打っても負け確定
                } else {
                    while (true) {
                        if (nextBoardList.get(nextBoardList.size()-1).value == Integer.MAX_VALUE) {
                            nextBoardList.remove(nextBoardList.size()-1); // 負け確定の手は取り除く
                        } else break;
                    }
                    r1 = rnd.nextInt (nextBoardList.size());
                    r2 = rnd.nextInt (nextBoardList.size());
                    if (r1<r2) r=r1; else r=r2; // 一応ランダムだが、評価値の低い手が選ばれる確率を高くする
                    nextBoard = nextBoardList.get (r);
                }
            }
            break;
        default : // レベル3以上 : n手先まで読んでレベル2と同等の処理
            int bestPlaces = 1; // 最善手の数
            if (turn == NOUGHT) { // ○番の場合
                nextBoard = nextBoardList.get(nextBoardList.size()-1); // 最も評価値の高い手を取り出す
                if (nextBoard.value == Integer.MAX_VALUE) { // 必勝手発見
                } else if (nextBoard.value == Integer.MIN_VALUE) { // どの手を打っても負け確定
                } else {
                    while (true) {
                        if (nextBoardList.get(0).value == Integer.MIN_VALUE) {
                            nextBoardList.remove(0); // 負け確定の手は取り除く
                        } else break;
                    }
                    if (nextBoardList.size() == 1) { // 負け確定以外の手が1つしか無い場合
                        nextBoard = nextBoardList.get(0);
                    } else {
                        for (int i=0; i<nextBoardList.size(); ++i) {
                            nextBoard = nextBoardList.get(i);
                            if (DEBUG) // デバグ情報(先読み無しの評価値)の表示
                                System.out.print ("着手:" + nextBoard.previousPlace + " 評価値:" + nextBoard.value);
                            int nextValue = nextBoard.computeValue (comLevel-1);    // 指定した手数を先読みして評価値を求める
                            if (DEBUG) // デバグ情報(先読み有りの評価値)の表示
                            System.out.println (" > " + nextBoard.value);
                            for (int j=0; j<i; ++j) { // 評価値順に並べ直す
                                if (nextBoardList.get(j).value > nextValue) {
                                    nextBoardList.remove (i);
                                    nextBoardList.add (j, nextBoard);
                                    break;
                                }
                            }
                        }
                        nextBoard = nextBoardList.get(nextBoardList.size()-1); // 最も評価値の高い手を取り出す
                        for (int i=nextBoardList.size()-2; i>=0; --i) // 最も評価値と高い手と同じ評価値の手の個数を数える
                            if (nextBoardList.get(i).value == nextBoard.value) ++bestPlaces; else break;
                        r = rnd.nextInt (bestPlaces);
                        nextBoard = nextBoardList.get(nextBoardList.size()-r-1); // 最も評価値の低い手からランダムに1手選択する
                    }
                }
            } else { // ×番の場合
                nextBoard = nextBoardList.get(0); // 最も評価値の高い手を取り出す
                if (nextBoard.value == Integer.MIN_VALUE) { // 必勝手発見
                } else if (nextBoard.value == Integer.MAX_VALUE) { // どの手を打っても負け確定
                } else {
                    while (true) {
                        if (nextBoardList.get(nextBoardList.size()-1).value == Integer.MAX_VALUE) {
                            nextBoardList.remove(nextBoardList.size()-1); // 負け確定の手は取り除く
                        } else break;
                    }
                    if (nextBoardList.size() == 1) { // 負け確定以外の手が1つしか無い場合
                        nextBoard = nextBoardList.get(0);
                    } else {            
                        for (int i=0; i<nextBoardList.size(); ++i) {
                            nextBoard = nextBoardList.get(i);
                            if (DEBUG) // デバグ情報(先読み無しの評価値)の表示
                                System.out.print ("着手:" + nextBoard.previousPlace + " 評価値:" + nextBoard.value);
                            int nextValue = nextBoard.computeValue (comLevel-1);    // 指定した手数を先読みして評価値を求める
                            if (DEBUG) // デバグ情報(先読み有りの評価値)の表示
                                System.out.println (" > " + nextBoard.value);
                            for (int j=0; j<i; ++j) { // 評価値順に並べ直す
                                if (nextBoardList.get(j).value > nextValue) {
                                    nextBoardList.remove (i);
                                    nextBoardList.add (j, nextBoard);
                                    break;
                                }
                            }
                        }
                        nextBoard = nextBoardList.get(0); // 最も評価値の低い手を取り出す
                        for (int i=1; i<nextBoardList.size(); ++i) // 最も評価値と低い手と同じ評価値の手の個数を数える
                            if (nextBoardList.get(i).value == nextBoard.value) ++bestPlaces; else break;
                        r = rnd.nextInt (bestPlaces);
                        nextBoard = nextBoardList.get(r); // 最も評価値の低い手からランダムに1手選択する
                    }
                }
                break;
            }
        }

        setStone (nextBoard.previousPlace);
    }

    /**
     * 指定した位置に手番側の石を打った盤面を作成する
     * @param int place : 石を打つ位置
     */
    private void setStone (int place) {
        board[place] = turn;    // 指定した位置に手番側の石を置く
        --emptySquares;         // 空白升の数を減らす
        previousPlace = place;  // 打った位置を記憶
    }

    /**
     * 手番を変更する
     * @return int : 手番 (1=○番, -1=×番)
     */
    int nextTurn() {
        if (turn == NOUGHT) turn = CROSS; else turn = NOUGHT;
        return turn;
    }

    /**
     * 手番側の勝利判定を行う
     * @return boolean : 手番側が勝ったか？
     */
    boolean doesWin() {
        computeValue();
        if (turn == NOUGHT) {
            if (maxLineValue == 3) return true;
        } else {
            if (minLineValue == -3) return true;
        } 
        return false;
    }

    /**
     * 盤面のコピーを作成する
     * @return Board : 盤面のコピー
     */
    Board copy() {
        Board newBoard = new Board();
        for (int i=1; i<=9; ++i) newBoard.board[i] = board[i];
        newBoard.turn = turn;
        newBoard.value = value;
        newBoard.maxLineValue = maxLineValue;
        newBoard.minLineValue = minLineValue;
        newBoard.resign = resign;
        newBoard.emptySquares = emptySquares;
        newBoard.previousPlace = previousPlace;
        return newBoard;
    }

    /**
     * 指定した位置に石を打った新たな盤面を作成する
     * @param int plce : 石を打つ位置
     * @return Board : 新たな盤面
     */
    Board nextBoard (int place) {
        Board nextBoard = copy();
        nextBoard.setStone (place);
        nextBoard.nextTurn();
        return nextBoard;
    }
}