DouKaku?

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class TicTacToe {
    public static final int SIZE = 3;

    private static final Pair[][] lines_ = new Pair[][] {
            { Pair.get(0, 0), Pair.get(0, 1), Pair.get(0, 2) },
            { Pair.get(1, 0), Pair.get(1, 1), Pair.get(1, 2) },
            { Pair.get(2, 0), Pair.get(2, 1), Pair.get(2, 2) },
            { Pair.get(0, 0), Pair.get(1, 0), Pair.get(2, 0) },
            { Pair.get(0, 1), Pair.get(1, 1), Pair.get(2, 1) },
            { Pair.get(0, 2), Pair.get(1, 2), Pair.get(2, 2) },
            { Pair.get(0, 0), Pair.get(1, 1), Pair.get(2, 2) },
            { Pair.get(2, 0), Pair.get(1, 1), Pair.get(0, 2) }, };
    public static final List<List<Pair>> LineList = new ArrayList<List<Pair>>();
    static {
        for (Pair[] line: lines_) {
            List<Pair> list = new ArrayList<Pair>();
            for (Pair pair: line) {
                list.add(pair);
            }
            LineList.add(Collections.unmodifiableList(list));
        }
    }

    private final Mark[][] fields_ = new Mark[SIZE][SIZE];

    public TicTacToe() {
        for (int x = 0; x < SIZE; x++) {
            for (int y = 0; y < SIZE; y++) {
                fields_[x][y] = Mark.E;
            }
        }
    }

    public Mark getMark(Pair pair) {
        return fields_[pair.x][pair.y];
    }

    public void setMark(Pair pair, Mark mark) {
        fields_[pair.x][pair.y] = mark;
    }

    public boolean nextStep(Pair pair, Mark mark) {
        if (getMark(pair) != Mark.E)
            return false;
        setMark(pair, mark);
        return true;
    }

    public Mark isEndGame() {
        for (Pair[] row : lines_) {
            Mark m = null;
            boolean isSame = true;
            for (Pair cell : row) {
                Mark mark = fields_[cell.x][cell.y];
                if (m == null) {
                    m = mark;
                    continue;
                }
                if (m != mark) {
                    isSame = false;
                    break;
                }
            }
            if (isSame)
                return m;
        }
        return Mark.E;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("%s|%s|%s%n",
                toString(getMark(Pair.get(0, 0))),
                toString(getMark(Pair.get(1, 0))),
                toString(getMark(Pair.get(2, 0)))));
        builder.append(String.format("-+-+-%n"));
        builder.append(String.format("%s|%s|%s%n",
                toString(getMark(Pair.get(0, 1))),
                toString(getMark(Pair.get(1, 1))),
                toString(getMark(Pair.get(2, 1)))));
        builder.append(String.format("-+-+-%n"));
        builder.append(String.format("%s|%s|%s%n",
                toString(getMark(Pair.get(0, 2))),
                toString(getMark(Pair.get(1, 2))),
                toString(getMark(Pair.get(2, 2)))));
        return builder.toString();
    }
    private String toString(Mark mark) {
        switch (mark) {
            case O:
            case X:
                return mark.toString();
            case E:
            default:
                return " ";
        }
    }

    public static void main(String[] args) {
        Player random1 = new RandomPlayer(Mark.O, "random1");
        Player random2 = new RandomPlayer(Mark.X, "random2");
        Player think1 = new ThinkingPlayer(Mark.O, "think1");
        Player think2 = new ThinkingPlayer(Mark.X, "think2");

        playGame(random1, random2);
        playGame(think1, random2);
        playGame(random1, think2);
        playGame(think1, think2);
    }

    private static void playGame(Player player1, Player player2) {
        int maxTurn = TicTacToe.SIZE * TicTacToe.SIZE;
        int[] result = new int[3];
        for (int round = 0; round < 10000; round++) {
            TicTacToe game = new TicTacToe();
            for (int turn = 0; turn <= maxTurn; turn++) {
                if (turn == maxTurn) {
                    result[2]++;
                    break;
                } else if (turn % 2 == 0) {
                    player1.put(game);
                } else {
                    player2.put(game);
                }
                Mark mark = game.isEndGame();
                if (mark == Mark.O) {
                    result[0]++;
                    break;
                } else if (mark == Mark.X) {
                    result[1]++;
                    break;
                }
            }
        }

        System.out.println("Result:");
        System.out.printf("%s won: %d%n", player1.name, result[0]);
        System.out.printf("%s won: %d%n", player2.name, result[1]);
        System.out.printf("draw game  : %d%n", result[2]);
    }
}

enum Mark {
    E {
        @Override public Mark getOpponent() { return E; }
    },
    O {
        @Override public Mark getOpponent() { return X; }
    },
    X {
        @Override public Mark getOpponent() { return O; }
    };

    public abstract Mark getOpponent();
}

class Pair {
    public final int x;
    public final int y;

    private Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }

    private static final List<Pair> cache = new ArrayList<Pair>();
    static {
        for (int x = 0; x < TicTacToe.SIZE; x++) {
            for (int y = 0; y < TicTacToe.SIZE; y++) {
                cache.add(new Pair(x, y));
            }
        }
    }
    public static Pair get(int x, int y) {
        return cache.get(x * TicTacToe.SIZE + y);
    }

    @Override
    public int hashCode() {
        return x * 3 + y;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj == this) return true;
        if (!(obj instanceof Pair)) return false;
        Pair other = (Pair) obj;
        return this.x == other.x && this.y == other.y;
    }
}

abstract class Player {
    public final Mark mark;
    public final String name;

    public Player(Mark mark, String name) {
        this.mark = mark;
        this.name = name;
    }
    public abstract void put(TicTacToe game);
}

class RandomPlayer extends Player {
    private final Random random_ = new Random();

    public RandomPlayer(Mark mark, String name) {
        super(mark, name);
    }

    @Override
    public void put(TicTacToe game) {
        if (game.isEndGame() != Mark.E) return;
        for (;;) {
            Pair pair = getNextPair();
            boolean res = game.nextStep(pair, mark);
            if (res)
                break;
        }
    }
    private Pair getNextPair() {
        return Pair.get(random_.nextInt(TicTacToe.SIZE), random_.nextInt(TicTacToe.SIZE));
    }
}

class ThinkingPlayer extends Player {
    private static final Pair CENTER = Pair.get(1, 1);
    private static final List<Pair> CORNER = new ArrayList<Pair>();
    private static final List<Pair> SIDES = new ArrayList<Pair>();

    public ThinkingPlayer(Mark mark, String name) {
        super(mark, name);
        CORNER.add(Pair.get(0, 0));
        CORNER.add(Pair.get(2, 2));
        CORNER.add(Pair.get(2, 0));
        CORNER.add(Pair.get(0, 2));
        SIDES.add(Pair.get(1, 0));
        SIDES.add(Pair.get(1, 2));
        SIDES.add(Pair.get(0, 1));
        SIDES.add(Pair.get(2, 1));
    }

    @Override
    public void put(TicTacToe game) {
        if (game.isEndGame() != Mark.E) return;
        
        int turn = 0;
        Map<Pair, Boolean> map = new HashMap<Pair, Boolean>();
        for (int x = 0; x < TicTacToe.SIZE; x++) {
            for (int y = 0; y < TicTacToe.SIZE; y++) {
                Pair pair = Pair.get(x, y);
                Mark mark = game.getMark(pair);
                if (mark == Mark.E) continue;
                turn++;
                map.put(pair, mark == this.mark);
            }
        }

        switch (turn) {
            case 0:
            case 1:
                priorityStep(game);
                break;
            case 2:
                {
                    if (map.get(CENTER) == null) {
                        game.nextStep(CENTER, this.mark);
                    } else {
                        for (int index = 0, size = CORNER.size(); index < size; index++) {
                            if (map.get(CORNER.get(index)) == Boolean.FALSE) {
                                int i = (index & 2) + (~index & 1);
                                boolean step = game.nextStep(CORNER.get(i), this.mark);
                                if (step) return;
                            }
                        }
                        priorityStep(game);
                    }
                }
                break;
            case 3:
                {
                    Set<Pair> winPair = searchWinPair(game, this.mark.getOpponent());
                    if (!winPair.isEmpty()) {
                        boolean step = game.nextStep(winPair.toArray(new Pair[0])[0], this.mark);
                        if (!step) throw new IllegalStateException(game.toString());
                        return;
                    }
                    if (game.getMark(CENTER) == this.mark) {
                        if ((game.getMark(CORNER.get(0)) == this.mark.getOpponent() && game.getMark(CORNER.get(1)) == this.mark.getOpponent())
                                || (game.getMark(CORNER.get(2)) == this.mark.getOpponent() && game.getMark(CORNER.get(3)) == this.mark.getOpponent())) {
                            for (Pair pair: SIDES) {
                                boolean step = game.nextStep(pair, this.mark);
                                if (step) return;
                            }
                        }
                    }
                    Set<Pair> goodPair = searchGoodPair(game, this.mark.getOpponent());
                    if (!goodPair.isEmpty()) {
                        boolean step = game.nextStep(goodPair.toArray(new Pair[0])[0], this.mark);
                        if (!step) throw new IllegalStateException(game.toString());
                        return;
                    }
                    priorityStep(game);
                }
                break;
            default:
                {
                    Set<Pair> winPair = searchWinPair(game, this.mark);
                    if (!winPair.isEmpty()) {
                        boolean step = game.nextStep(winPair.toArray(new Pair[0])[0], this.mark);
                        if (!step) throw new IllegalStateException(game.toString());
                        return;
                    }
                    Set<Pair> losePair = searchWinPair(game, this.mark.getOpponent());
                    if (!losePair.isEmpty()) {
                        boolean step = game.nextStep(losePair.toArray(new Pair[0])[0], this.mark);
                        if (!step) throw new IllegalStateException(game.toString());
                        return;
                    }
                    Set<Pair> noGoodPair = searchGoodPair(game, this.mark.getOpponent());
                    if (!noGoodPair.isEmpty()) {
                        boolean step = game.nextStep(noGoodPair.toArray(new Pair[0])[0], this.mark);
                        if (!step) throw new IllegalStateException(game.toString());
                        return;
                    }
                    Set<Pair> goodPair = searchGoodPair(game, this.mark);
                    if (!goodPair.isEmpty()) {
                        boolean step = game.nextStep(goodPair.toArray(new Pair[0])[0], this.mark);
                        if (!step) throw new IllegalStateException(game.toString());
                        return;
                    }
                    priorityStep(game);
                }
                break;
        }
    }

    private void priorityStep(TicTacToe game) {
        boolean step = false;
        {
            step = game.nextStep(CENTER, this.mark);
            if (step) return;
        }
        for (Pair pair: CORNER) {
            step = game.nextStep(pair, this.mark);
            if (step) return;
        }
        for (Pair pair: SIDES) {
            step = game.nextStep(pair, this.mark);
            if (step) return;
        }
    }

    private Set<Pair> searchWinPair(TicTacToe game, Mark mark) {
        Set<Pair> list = new HashSet<Pair>();
        for (List<Pair> line: TicTacToe.LineList) {
            int count = 0;
            Pair empty = null;
            for (Pair pair: line) {
                if (game.getMark(pair) == mark) {
                    count++;
                } else if (game.getMark(pair) == mark.getOpponent()) {
                    count = -1;
                    break;
                } else {
                    empty = pair;
                }
            }
            if (count == 2 && empty != null) list.add(empty);
        }
        return list;
    }

    private Set<Pair> searchGoodPair(TicTacToe game, Mark mark) {
        Set<Pair> list = new HashSet<Pair>();
        for (int x = 0; x < TicTacToe.SIZE; x++) {
            for (int y = 0; y < TicTacToe.SIZE; y++) {
                Pair pair = Pair.get(x, y);
                if (game.getMark(pair) == Mark.E) {
                    game.setMark(pair, mark);
                    Set<Pair> winPair = searchWinPair(game, mark);
                    if (winPair.size() > 1) list.add(pair);
                    game.setMark(pair, Mark.E);
                }
            }
        }
        return list;
    }
}

import java.util.Random

class TicTacToe(val players:List[Player]) {
  val size = 3
  protected val field = new Array[Array[char]](size,size)
  val lines = (_stline((v,v2) => (v,v2))++_stline((v,v2) => (v2,v))++
              List(((size-1).until(-1,-1)).map(v=> (v,(size-1-v)))) ++
              List((0 until size).map(v=>(v,v)))).map(_.toList)

  def _stline(f:(int,int) => Pair[int,int]) = 
    (0 until size).map(v => (0 until size).map(v2 => f(v,v2)))

  def start:Option[Player] = {
    for(val i<-(0 until size); val j<-(0 until size)) { field(i)(j) = ' '}
    Stream.const(players).flatMap(v=>v).take(size*size).find {player => 
      val p@Pair(y,x) = player.put(this)
      if(!available_?(p)) error("Oops!")
      field(y)(x) = player.mark
      judge
    }
  }

  def judge = lines.exists(l => l.forall(!available_?(_)) && l.forall(v => at(l(0)) == at(v)))
  def available_?(pos:Pair[int,int]) = at(pos) equals ' '
  def at(pos:Pair[int,int]) = field(pos._1)(pos._2)
  def at_eq(pos:Pair[int,int], mark:char) = at(pos) equals mark
  def enemy_of(player:Player) = players.find{_.mark != player.mark}.get
}

abstract class Player{
  val mark:char
  val name:String
  def put(ttt:TicTacToe):Pair[int,int]
}

class RandomPlayer(override val mark:char, override val name:String) extends Player{
  val rnd = new Random
  override def put(ttt:TicTacToe) = {
    def _n = (rnd.nextInt(ttt.size), rnd.nextInt(ttt.size))
    def next(v:Pair[int,int]):Stream[Pair[int,int]] = Stream.cons(v, next(_n))
    next(_n).find(ttt.available_?).get
  }
}

class CleverPlayer(override val mark:char, override val name:String) extends Player {
  override def put(ttt:TicTacToe):Pair[int,int] = {
    val enemy = ttt.enemy_of(this)
    val return_if_available_find = (l:Seq[Pair[int,int]]) => l.find(ttt.available_?) match {
      case Some(pos) => return pos
      case _ => ()
    }

    def line2(v:char) = ttt.lines.filter(_.count(ttt.at_eq(_,v)) == 2)
    return_if_available_find(List(mark, enemy.mark).flatMap(line2).flatMap(v=>v))

    val all  = (for(val i<-(0 until ttt.size); val j<-(0 until ttt.size)) yield (i,j)).toList
    val center = (ttt.size/2, ttt.size/2)
    val corners = List((0,0), (ttt.size-1,ttt.size-1), (0,ttt.size-1), (ttt.size-1, 0))
    val others = all.diff(center::corners)

    if(all.count(ttt.at_eq(_, enemy.mark)) == 2 && ttt.at_eq(center, this.mark)) {
      if(!others.forall(ttt.available_?)) {
        val ps = all.filter(ttt.at_eq(_, enemy.mark))
        def vecv(a:Pair[int,int]) = (0 /: ps){(r, p) => r+(a._1 - p._1).abs+(a._2 - p._2).abs}
        return_if_available_find(corners.sort(vecv(_) < vecv(_)))
      }
      return_if_available_find(others)
    }

    return_if_available_find(List(center))
    return_if_available_find(corners)
    others.find(ttt.available_?).get
  }
}

#include "Player.h"

class BetterPlayer:public Player{//長さ３専用
public:
    char*GetName(){ return "BetterThinkPlayer.";}
    void Play(MBGame& in){
        if(in.HasEmpty() && in.Length()>3) {
            while(in.SetStone(rand()%in.Length(),rand()%in.Length(),Mark_));
            return;
        }
        //マスの重み
        short Point[]={    43,27 ,41,
                        28,100,26,
                        42,29 ,44,
        };
        int op=0;
        do{
            if(!in.HasEmpty()) return;
            think(in,Point,sizeof(Point));
            for(int i=0;i<sizeof(Point);i++){
                if(Point[i] >Point[op]){
                    op=i;
                }
            }
            Point[op]=-10000;
        }while(!in.SetStone(op%3,op/3,Mark_));
        
    }
protected:
    
    void think(MBGame& in,short Point[],int N){
        const short Posi = 10;
        const short Nega = -5;
        const short denger =9999;
        char Lines[8][3]={
                        {0,1,2},{3,4,5},{6,7,8},//横
                        {0,3,6},{1,4,7},{2,5,8},//縦
                        {0,4,8},{2,4,6},//斜め
        };
        char Side[9][9]={    
                        {1,3,-1},//-1は番兵
                        {0,2,4,-1},
                        {1,5,-1},
                        {0,4,6,-1},
                        {0,1,2,3,5,6,7,8,-1},
                        {2,4,8,-1},
                        {3,7,-1},
                        {6,4,8,-1},    
                        {5,7,-1},
        };
        for(int i=0;i<9;i++){//こまの配置による判定
            for(int j=0;Side[i][j]!= -1;j++){
                int x=0,y=0;
                int N = Side[i][j];
                x = N%3;
                y = N/3;
                Mark M= in.At(x,y);
                if(M == Mark_) Point[Side[i][j]]+= Posi;
                if(M != Mark_ && M != None ) Point[Side[i][j]]+= Nega;
            }
        }
        for(int i=0;i<8;i++){//超危ない時の判定
            int P=0;
            int x=0,y=0;
            for(int j=0;j<3;j++){
                int N= Lines[i][j];
                x = N%3;
                y = N/3;
                Mark M = in.At(x,y);
                if(M == Mark_) P++;
                if(M != None && M != Mark_) P--;
            }
            for(int j=0;j<3;j++){
                if(P == 2) Point[Lines[i][j]]+=denger;
                if(P == -2) Point[Lines[i][j]]+=denger;
            }
        }
    }

};

        for(int i=0;i<9;i++){//こまの配置による判定
            int x,y;
                x = i%3;
                y = i/3;
            Mark M= in.At(x,y);
            for(int j=0;Side[i][j]!= -1;j++){
                if(M == Mark_) Point[Side[i][j]]+= Posi;
                if(M != Mark_ && M != None ) Point[Side[i][j]]+= Nega;
            }
        }

| 全マス目 全ライン 勝敗カウンタ 中央のマス 隅のマス群 縁のマス群 |

中央のマス := #(2 2).
隅のマス群 := #((1 1) (3 3) (1 3) (3 1)).
縁のマス群 := #((1 2) (3 2) (2 1) (2 3)).
全マス目 := (中央のマス, 隅のマス群, 縁のマス群) asOrderedCollection.

全ライン := OrderedCollection new.
(1 to: 3) do: [:座標１ |
    全ライン add: ((1 to: 3) collect: [:座標２ | {座標１. 座標２}]).
    全ライン add: ((1 to: 3) collect: [:座標２ | {座標２. 座標１}])].
全ライン add: #((1 1) (2 2) (3 3)); add: #((1 3) (2 2) (3 1)).

^#(賢い先手 #賢い後手 #賢い両者) collect: [:モード |

    勝敗カウンタ := Bag new.

    1e4 timesRepeat: [
        | 残りマス群 先手 後手 打ち手順 ランダム 手番 結果 |
        残りマス群 := 全マス目 copy.
        先手 := OrderedCollection new. 後手 := 先手 copy.
        打ち手順 := {先手. 後手}.
        ランダム := モード caseOf: {
                [#賢い先手] -> [後手].
                [#賢い後手] -> [先手]}
            otherwise: [nil].
        手番 := 0.
        結果 := nil.

        [残りマス群
            ifEmpty: [結果 := #引き分け]
            ifNotEmpty: [
                | 打ち手 敵の手 必勝手検索 必勝の手 守りの手 詰み回避の手 最善手 打つ手 |
                打ち手 := 打ち手順 atWrap: (手番 := 手番 + 1).
                敵の手 := 打ち手順 atWrap: 手番 + 1.

                必勝手検索 := [:対象マス群 |
                    | 候補群 |
                    全ライン
                        detect: [:構成マス群 |
                            (候補群 := 構成マス群 difference: 対象マス群) size = 1 and: [
                                残りマス群 includesAllOf: 候補群]]
                        ifNone: [候補群 := #()]..
                    候補群 ifNotEmpty: [候補群 first] ifEmpty: [nil]].

                必勝の手 := [必勝手検索 value: 打ち手].
                守りの手 := [必勝手検索 value: 敵の手].

                詰み回避の手 := [
                    (残りマス群 includes: 中央のマス) ifTrue: [中央のマス] ifFalse: [
                        (敵の手 includesAnyOf: {隅のマス群 first: 2. 隅のマス群 last: 2})
                            ifTrue: [縁のマス群 first]
                            ifFalse: [
                                (隅のマス群 intersection: 残りマス群)
                                    ifNotEmptyDo: [:候補群 |
                                        候補群 detectMin: [:候補 |
                                            敵の手 inject: 0 into: [:総和 :敵のマス |
                                                総和 + (敵のマス * 候補) sum]]]
                                    ifEmpty: [nil]]]].

                最善手 := [
                    必勝の手 value ifNil: [
                        守りの手 value ifNil: [
                            詰み回避の手 value ifNil: [残りマス群 atRandom]]]].

                打つ手 := 打ち手 ~~ ランダム ifTrue: [最善手 value] ifFalse: [残りマス群 atRandom].
                打ち手 add: (残りマス群 remove: 打つ手).
                (全ライン anySatisfy: [:必須マス群 | 打ち手 includesAllOf: 必須マス群])
                    ifTrue: [結果 := 打ち手 == 先手 ifTrue: [#先手勝ち] ifFalse: [#後手勝ち]]].
        結果 isNil] whileTrue.

        勝敗カウンタ add: 結果].

    モード -> 勝敗カウンタ sortedCounts asArray]

"=> {#賢い先手->{9774->#先手勝ち. 226->#引き分け}. 
    #賢い後手->{7962->#後手勝ち. 2038->#引き分け}. 
    #賢い両者->{10000->#引き分け}} "

6c6
< 全マス目 := (中央のマス, 隅のマス群, 縁のマス群) asOrderedCollection.
---
> 全マス目 := ({中央のマス}, 隅のマス群, 縁のマス群) asOrderedCollection.
51c51,52
<                         (敵の手 includesAnyOf: {隅のマス群 first: 2. 隅のマス群 last: 2})
---
>                         (敵の手 size = 2 and: [{隅のマス群 first: 2. 隅のマス群 last: 2}
>                                 anySatisfy: [:二隅 | (敵の手 copyWithoutAll: 二隅) isEmpty]])
58c59
<                                                 総和 + (敵のマス * 候補) sum]]]
---
>                                                 総和 + ((候補 - 敵のマス) * (候補 - 敵のマス)) sum]]]
76,77c77,78
< "=> {#賢い先手->{9774->#先手勝ち. 226->#引き分け}. 
<     #賢い後手->{7962->#後手勝ち. 2038->#引き分け}. 
---
> "=>  {#賢い先手->{9607->#先手勝ち. 393->#引き分け}.
>     #賢い後手->{8544->#後手勝ち. 1456->#引き分け}.

ヒント：
short Point[]={    20,15 ,18,
                    14,16,13,
                    17,12 ,19,
        };
このような重み付けの相手に弱くはありませんか？
（実際に試してはいないので、違ったらスミマセン。）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct tag_game
{
    int map_x;
    int map_o;
} OXGAME , *LPOXGAME;

#define Match(x,pat) ((((x) & 0x0FFF) & (pat)) == (pat))

/* フィールド固有フラグ */
#define NO_0 0x0001
#define NO_1 0x0002
#define NO_2 0x0004
#define NO_3 0x0010
#define NO_4 0x0020
#define NO_5 0x0040
#define NO_6 0x0100
#define NO_7 0x0200
#define NO_8 0x0400

/* フィールド逆引き用 */
static int map_num[9] = {
    NO_0, NO_1, NO_2,
    NO_3, NO_4, NO_5,
    NO_6, NO_7, NO_8,
};

/* フィールド表示 */
static char ox_print_sub(LPOXGAME g, int pat)
{
    if(Match(g->map_o, (pat))) return 'O';
    if(Match(g->map_x, (pat))) return 'X';
    return ' ';
}
int ox_print(LPOXGAME g)
{
    printf( "+-+-+-+\n"
            "|%c|%c|%c|\n"
            "+-+-+-+\n"
            "|%c|%c|%c|\n"
            "+-+-+-+\n"
            "|%c|%c|%c|\n"
            "+-+-+-+",
        ox_print_sub(g,NO_0), ox_print_sub(g,NO_1), ox_print_sub(g,NO_2),
        ox_print_sub(g,NO_3), ox_print_sub(g,NO_4), ox_print_sub(g,NO_5),
        ox_print_sub(g,NO_6), ox_print_sub(g,NO_7), ox_print_sub(g,NO_8));

    return 0;
}

/* 点数計算 */
/* @- int ox_match(LPOXGAME g)
 *    ^^^  > 0 : win O
 *        == 0 : tie
 *         < 0 : win X
 */
static int ox_match_sub(int x)
{
    int pts = 0;

    if(Match( x , (NO_0|NO_1|NO_2))) pts++;
    if(Match( x , (NO_3|NO_4|NO_5))) pts++;
    if(Match( x , (NO_6|NO_7|NO_8))) pts++;

    if(Match( x , (NO_0|NO_3|NO_6))) pts++;
    if(Match( x , (NO_1|NO_4|NO_7))) pts++;
    if(Match( x , (NO_2|NO_5|NO_8))) pts++;

    if(Match( x , (NO_0|NO_4|NO_8))) pts++;
    if(Match( x , (NO_2|NO_4|NO_6))) pts++;

    return pts;
}
int ox_match(LPOXGAME g)
{
    return ox_match_sub(g->map_o) - ox_match_sub(g->map_x);
}

/* 打ち位置計算 ロボ */
/* @- int ox_play(LPOXGAME g)
 *    ^^^ != 0 : 打ち位置
 *    ^^^ == 0 : error
 */
int ox_play(LPOXGAME g)
{
    int x, m;

    m = g->map_o | g->map_x;
    if(Match(m, (NO_0|NO_1|NO_2|
                 NO_3|NO_4|NO_5|
                 NO_6|NO_7|NO_8))) return 0; /* map full */
    for(;;) {
        x = map_num[rand() % 9]; /* ←頭脳 */
        if(!Match(m, x)) return x; /* 空いてるならここ */
    }

    return 0;
}

/* ox_play_tuyoi */
int ox_is_reach( LPOXGAME g, int x )
{
    int m;
    m = g->map_o | g->map_x;
/*
 012
 345
 678
*/
    /* リーチ 置石優先順位 4 > 0,2,6,8 > 1,3,5,7 */
/* --- */
    if(Match( x , (NO_0|NO_8)) && (!Match( m , (NO_4))) ) return NO_4;
    if(Match( x , (NO_2|NO_6)) && (!Match( m , (NO_4))) ) return NO_4;
    if(Match( x , (NO_3|NO_5)) && (!Match( m , (NO_4))) ) return NO_4;
    if(Match( x , (NO_1|NO_7)) && (!Match( m , (NO_4))) ) return NO_4;

    if(Match( x , (NO_1|NO_2)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( x , (NO_3|NO_6)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( x , (NO_4|NO_8)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( x , (NO_5|NO_8)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( x , (NO_4|NO_6)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( x , (NO_0|NO_1)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( x , (NO_7|NO_8)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( x , (NO_0|NO_3)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( x , (NO_2|NO_4)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( x , (NO_6|NO_7)) && (!Match( m , (NO_8))) ) return NO_8;
    if(Match( x , (NO_2|NO_5)) && (!Match( m , (NO_8))) ) return NO_8;
    if(Match( x , (NO_0|NO_4)) && (!Match( m , (NO_8))) ) return NO_8;
                                                
    if(Match( x , (NO_0|NO_2)) && (!Match( m , (NO_1))) ) return NO_1;
    if(Match( x , (NO_4|NO_7)) && (!Match( m , (NO_1))) ) return NO_1;
    if(Match( x , (NO_0|NO_6)) && (!Match( m , (NO_3))) ) return NO_3;
    if(Match( x , (NO_4|NO_5)) && (!Match( m , (NO_3))) ) return NO_3;
    if(Match( x , (NO_2|NO_8)) && (!Match( m , (NO_5))) ) return NO_5;
    if(Match( x , (NO_3|NO_4)) && (!Match( m , (NO_5))) ) return NO_5;
    if(Match( x , (NO_1|NO_4)) && (!Match( m , (NO_7))) ) return NO_7;
    if(Match( x , (NO_6|NO_8)) && (!Match( m , (NO_7))) ) return NO_7;

    return 0;
}
int ox_play_tuyoi(LPOXGAME g, const char player)
{
    int xa, xb, m, xr;

    if(player == 'O') {
        xa = g->map_o; /* O プレイヤ優先*/
        xb = g->map_x;
    }

    if(player == 'X') {
        xa = g->map_x; /* X プレイヤ優先 */
        xb = g->map_o;
    }
    m = g->map_o | g->map_x;
    if(Match(m, (NO_0|NO_1|NO_2|
                 NO_3|NO_4|NO_5|
                 NO_6|NO_7|NO_8))) return 0; /* map full */

    /* リーチなら埋めて勝つ */
    if(xr = ox_is_reach(g, xa)) return xr;

    /* 敵リーチ 阻止 */
    if(xr = ox_is_reach(g, xb)) return xr;

/*
  0 1 2
  3 4 5
  6 7 8
*/
    /* とりあえず 4 > (xb) > 0,2,6,8 > 1,3,5,7 */
    if(!(Match( m , (NO_4)))) return NO_4;

/*
 3パターン 2パターン混合:
 16 => 0
 18 => 2

 32 => 0
 38 => 6

 50 => 2
 56 => 8

 70 => 6
 72 => 8
*/
    if(Match( xb , (NO_1|NO_6)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( xb , (NO_1|NO_8)) && (!Match( m , (NO_2))) ) return NO_2;

    if(Match( xb , (NO_3|NO_2)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( xb , (NO_3|NO_8)) && (!Match( m , (NO_6))) ) return NO_6;

    if(Match( xb , (NO_5|NO_0)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( xb , (NO_5|NO_6)) && (!Match( m , (NO_8))) ) return NO_8;

    if(Match( xb , (NO_7|NO_0)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( xb , (NO_7|NO_2)) && (!Match( m , (NO_8))) ) return NO_8;

/*
  0 1 2
  3 4 5
  6 7 8
*/
/* 
 3パターン用) 近接置石: 真ん中 > 角 > そのほか
 0 => 4,> 2, 6 > 1, 3
 2 => 4,> 0, 8 > 1, 5
 6 => 4,> 0, 8 > 3, 7
 8 => 4,> 2, 6 > 5, 7
*/
    if(Match( xb , (NO_0)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( xb , (NO_0)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( xb , (NO_0)) && (!Match( m , (NO_1))) ) return NO_1;
    if(Match( xb , (NO_0)) && (!Match( m , (NO_3))) ) return NO_3;

    if(Match( xb , (NO_2)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( xb , (NO_2)) && (!Match( m , (NO_8))) ) return NO_8;
    if(Match( xb , (NO_2)) && (!Match( m , (NO_1))) ) return NO_1;
    if(Match( xb , (NO_2)) && (!Match( m , (NO_5))) ) return NO_5;

    if(Match( xb , (NO_4)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( xb , (NO_4)) && (!Match( m , (NO_8))) ) return NO_8;
    if(Match( xb , (NO_4)) && (!Match( m , (NO_3))) ) return NO_3;
    if(Match( xb , (NO_4)) && (!Match( m , (NO_7))) ) return NO_7;

    if(Match( xb , (NO_8)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( xb , (NO_8)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( xb , (NO_8)) && (!Match( m , (NO_5))) ) return NO_5;
    if(Match( xb , (NO_8)) && (!Match( m , (NO_7))) ) return NO_7;

/*
  0 1 2
  3 4 5
  6 7 8
*/
/*
 2パターン用) 近接置石: 真ん中 > 角

 1 => 4,> 0, 2
 3 => 4,> 0, 6
 5 => 4,> 2, 8
 7 => 4,> 6, 8
*/

    if(Match( xb , (NO_1)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( xb , (NO_1)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( xb , (NO_3)) && (!Match( m , (NO_0))) ) return NO_0;
    if(Match( xb , (NO_3)) && (!Match( m , (NO_6))) ) return NO_6;

    if(Match( xb , (NO_5)) && (!Match( m , (NO_2))) ) return NO_2;
    if(Match( xb , (NO_5)) && (!Match( m , (NO_8))) ) return NO_8;
    if(Match( xb , (NO_7)) && (!Match( m , (NO_6))) ) return NO_6;
    if(Match( xb , (NO_7)) && (!Match( m , (NO_8))) ) return NO_8;

/*
 012
 345
 678
*/  
/* 適当に置く: 真ん中 > 角 */
    if(!(Match( m , (NO_0)))) return NO_0;
    if(!(Match( m , (NO_2)))) return NO_2;
    if(!(Match( m , (NO_6)))) return NO_6;
    if(!(Match( m , (NO_8)))) return NO_8;

    if(!(Match( m , (NO_1)))) return NO_1;
    if(!(Match( m , (NO_5)))) return NO_5;
    if(!(Match( m , (NO_3)))) return NO_3;
    if(!(Match( m , (NO_7)))) return NO_7;

    return 0;
}



/* フィールドにコマ打ち */
int ox_write(LPOXGAME g, const char player, const int x)
{
    int m;

    m = g->map_o | g->map_x;
    if(Match(m, (NO_0|NO_1|NO_2|
                 NO_3|NO_4|NO_5|
                 NO_6|NO_7|NO_8))) return 0; /* map full */

    if(Match(m, x)) return 0; /* error */
    if(player == 'O') g->map_o |= x; /* O プレイヤ処理 */
    if(player == 'X') g->map_x |= x; /* X プレイヤ処理 */

    return 0;
}

/* フィールド初期化処理 */
int ox_init(LPOXGAME g)
{
    g->map_o = 0;
    g->map_x = 0;

    return 0;
}

/* OX プロセス */
int ox_proc(LPOXGAME g)
{
    int x,t;

    ox_init(g);

    for(;;) {
        /*---------*/
        x = ox_play(g); /* 打てる場所を捜す */
//        x = ox_play_tuyoi(g, 'O'); /* tuyoi O */
        ox_write(g, 'O', x); /* 打つ */
        t = ox_match(g); /* 並んでいるか? */
        if(t) break; /* 並んでいる */
        if(!x) break; /* map full */

        /*---------*/
//        x = ox_play(g); /* 打てる場所を捜す */
        x = ox_play_tuyoi(g, 'X'); /* tuyoi X */
        ox_write(g, 'X', x);
        t = ox_match(g);
        if(t) break;
        if(!x) break; /* map full */
    }
    ox_print(g); /* フィールド表示 */
    t = ox_match(g);

    if(t > 0)       printf("... [Win: O]\n");
    else if(t < 0)  printf("... [Win: X]\n");
    else            printf("... [Tie]\n");

    return t;
}

/* */
int main()
{
    int i, t;
    int o = 0,x = 0, ox = 0;
    OXGAME g;

    srand(time(0));

    for(i= 0; i< 10000; i++) {
        t = ox_proc(&g);

        if(t > 0)       o++;
        else if(t < 0)  x++;
        else            ox++;
/*      printf("%ld) O:%ld, X:%ld, T:%ld\n", i,  o, x, ox);*/
    }

    printf("O:%ld, X:%ld, T:%ld\n", o, x, ox);
    return 0;
}

/**
random:
O:5828, X:2899, T:1273
O:5785, X:2911, T:1304
O:5863, X:2899, T:1238

tuyoi O:
O:9593, X:0, T:407
O:9598, X:0, T:402
O:9560, X:0, T:440
O:9630, X:0, T:370

tuyoi X:
O:49, X:8573, T:1378
O:45, X:8584, T:1371
O:65, X:8571, T:1364
O:48, X:8560, T:1392

**/

(use srfi-1)
(use gauche.sequence)

(define lset-board  '(0 1 2 3 4 5 6 7 8))
(define lset-corner '(0 2 6 8))
(define lset-edge   '(1 3 5 7))

(define (win? l)
  (any (cut lset<= = <> l)
       '((0 1 2) (3 4 5) (6 7 8) (0 3 6) (1 4 7) (2 5 8) (0 4 8) (2 4 6))))

(define (vacant self other)
  (lset-difference = lset-board (append self other)))

(define (player-random self other)
  (cond ((vacant self other) pair?
     => (lambda (v)
          (cons (car (shuffle v)) self)))
    (else #f)))

(define (player-wise self other)
  (define (next-win v pself)
    (cond ((find win? (map (cut cons <> pself) v))
       => car)
      (else #f)))

  (define (corner-has-neighber corners)
    (define table '((0 1 3) (2 1 5) (6 3 7) (8 7 5)))
    (find (lambda (c)
        (and (pair? (lset-intersection = (cdr (assq c table)) other)) c))
      corners))
    
  (cond ((vacant self other) 
     pair? => (lambda (v)
            (cond ((next-win v self)  => (cut cons <> self))
              ((next-win v other) => (cut cons <> self))
              ((memq 4 v)            (cons 4 self))
              ((or (lset= = other '(0 8)) ;; oxo
                   (lset= = other '(2 6)))
               (cons (car (lset-intersection = v lset-edge))
                 self))
              ((lset-intersection = v lset-corner)
               pair? => (lambda (cs)
                      (cons
                       (or (corner-has-neighber cs)
                       (car cs))
                       self)))
              (else ; edge
               (cons (car v) self))
              )))
    (else #f)))

(define (a-play p1a p2a)
  (define (p1-turn p1 p2)
    (cond ((win? p2) 'lose)
      ((p1a p1 p2) => (cut p2-turn <> p2))
      (else 'draw)))
  (define (p2-turn p1 p2)
    (cond ((win? p1) 'win)
      ((p2a p2 p1) => (cut p1-turn p1 <>))
      (else 'draw)))
  (p1-turn () ()))

(define (play p1a p2a)
  (let new-game ((win 0)
         (lose 0)
         (draw 0))
    (if (<= 10000 (+ win lose draw))
    (format #t "player1 won: ~a\tplayer2 won: ~a\tdraw: ~a\n" win lose draw)
    (case (a-play p1a p2a)
      ((win)  (new-game (+ win 1) lose draw))
      ((lose) (new-game win (+ lose 1) draw))
      ((draw) (new-game win lose (+ 1 draw)))))))

(play player-random player-random)
(play player-wise player-random)
(play player-random player-wise)
(play player-wise player-wise)

(use srfi-1)
(use srfi-27)
(use util.list)

(define lset-board  '(0 1 2 3 4 5 6 7 8))
(define lset-corner '(0 2 6 8))
(define lset-edge   '(1 3 5 7))

(define (includes? a b)
  (cond
   ((null? b) ())
   ((memq (car b) a)
    (includes? a (cdr b)))
   (else #f)))

(define (sand a b)
  (filter (cut memq <> b) a))

(define (sdif a b)
  (remove (cut memq <> b) a))

(define (win? l)
  (let next ((pat '((0 1 2) (3 4 5) (6 7 8) 
            (0 3 6) (1 4 7) (2 5 8) 
            (0 4 8) (2 4 6))))
    (cond
     ((null? pat) #f)
     ((includes? l (car pat)) #t)
     (else (next (cdr pat))))))

(define (vacant self other)
  (sdif lset-board (append self other)))

(define (player-random self other)
  (define (random-take klist)
    (ref klist (random-integer (length klist))))

  (cond
   ((vacant self other)
    pair? => (lambda (v) (cons (random-take v) self)))
   (else #f)))

(define (player-wise self other)
  (define (next-win vs self)
    (cond
     ((< (length self) 2) #f) ;; shortcut
     ((find win? (map (cut cons <> self) vs))
      => car)
     (else #f)))

  (define (corner-has-neighber vcorners)
    (define table '((0 1 3) (2 1 5) (6 3 7) (8 7 5)))
    (define (has-neighber? vc)
      (and (includes? vc '(1 3 5 7)) ;; shortcut
       (pair? (sand (cdr (assq vc table)) other))))
    (find (lambda (vc) (and (has-neighber? vc) vc))
      vcorners))
    
  (cond
   ((vacant self other)
    pair? => (lambda (v)
           (cond
        ((next-win v self)  => (cut cons <> self))
        ((next-win v other) => (cut cons <> self))
        ((memq 4 v)            (cons 4 self))
        ((and (= 2 (length other))
              (or (includes? other '(0 8))
              (includes? other '(2 6))))
         (cons (car (lset-intersection = v lset-edge))
               self))
        ((sand v lset-corner)
         pair? => (lambda (cs)
                (cons
                 (or (corner-has-neighber cs)
                 (car cs))
                 self)))
        (else ; edge
         (cons (car v) self))
        )))
   (else #f)))

(define (a-play p1a p2a)
  (define (p1-turn p1 p2)
    (cond
     ((win? p2) 'lose)
     ((p1a p1 p2) => (cut p2-turn <> p2))
     (else 'draw)))
  (define (p2-turn p1 p2)
    (cond
     ((win? p1) 'win)
     ((p2a p2 p1) => (cut p1-turn p1 <>))
     (else 'draw)))
  (p1-turn () ()))

(define (play p1a p2a)
  (let new-game ((win 0)
         (lose 0)
         (draw 0))
    (if (<= 10000 (+ win lose draw))
    (format #t "player1 won: ~a\tplayer2 won: ~a\tdraw: ~a\n" win lose draw)
    (case (a-play p1a p2a)
      ((win)  (new-game (+ win 1) lose draw))
      ((lose) (new-game win (+ lose 1) draw))
      ((draw) (new-game win lose (+ 1 draw)))))))

(time (play player-random player-random))
(time (play player-wise player-random))
(time (play player-random player-wise))
(time (play player-wise player-wise))

struct 
{
    int pat;
    int out;
} reach[] = {
 {NO_0|NO_8, NO_4}, {NO_2|NO_6, NO_4}, {NO_3|NO_5, NO_4}, {NO_1|NO_7, NO_4},

 {NO_1|NO_2, NO_0}, {NO_3|NO_6, NO_0}, {NO_4|NO_8, NO_0},
 {NO_5|NO_8, NO_2}, {NO_4|NO_6, NO_2}, {NO_0|NO_1, NO_2},
 {NO_7|NO_8, NO_6}, {NO_0|NO_3, NO_6}, {NO_2|NO_4, NO_6},
 {NO_6|NO_7, NO_8}, {NO_2|NO_5, NO_8}, {NO_0|NO_4, NO_8},

 {NO_0|NO_2, NO_1}, {NO_4|NO_7, NO_1},
 {NO_0|NO_6, NO_3}, {NO_4|NO_5, NO_3},
 {NO_2|NO_8, NO_5}, {NO_3|NO_4, NO_5},
 {NO_1|NO_4, NO_7}, {NO_6|NO_8, NO_7},
 { 0 , 0 }, 
};

struct 
{
    int pat;
    int out;
} pattern[] = {
 {0, NO_4 }, 
 {NO_4, NO_0}, { NO_4, NO_2}, {NO_4, NO_6}, {NO_4, NO_8}, 
 {NO_0|NO_8, NO_1}, {NO_0|NO_8, NO_3}, 
 {NO_0|NO_8, NO_5}, {NO_0|NO_8, NO_7}, 
 {NO_6|NO_2, NO_1}, {NO_6|NO_2, NO_3}, 
 {NO_6|NO_2, NO_5}, {NO_6|NO_2, NO_7}, 
 {NO_1|NO_6, NO_0}, {NO_1|NO_8, NO_2}, 
 {NO_3|NO_2, NO_0}, {NO_3|NO_8, NO_6}, 
 {NO_5|NO_0, NO_2}, {NO_5|NO_6, NO_8}, 
 {NO_7|NO_0, NO_6}, {NO_7|NO_2, NO_8}, 
 {NO_0, NO_2}, {NO_0, NO_6}, {NO_0, NO_1}, {NO_0, NO_3}, 
 {NO_2, NO_0}, {NO_2, NO_8}, {NO_2, NO_1}, {NO_2, NO_5}, 
 {NO_4, NO_0}, {NO_4, NO_8}, {NO_4, NO_3}, {NO_4, NO_7}, 
 {NO_8, NO_2}, {NO_8, NO_6}, {NO_8, NO_5}, {NO_8, NO_7}, 
 {NO_1, NO_2}, {NO_1, NO_0}, 
 {NO_3, NO_0}, {NO_3, NO_6}, 
 {NO_5, NO_2}, {NO_5, NO_8}, 
 {NO_7, NO_6}, {NO_7, NO_8}, 
 {0, NO_0}, {0, NO_2}, {0, NO_6}, {0, NO_8}, 
 {0, NO_1}, {0, NO_5}, {0, NO_3}, {0, NO_7}, 
 { 0 , 0 }, 
};


/* ox_play_tuyoi */
int ox_is_reach( LPOXGAME g, int x )
{
    int m, i;
    m = g->map_o | g->map_x;

   for(i = 0; reach[i].out != 0; i++ )
    if( Match( x , reach[i].pat )
       && (!Match( m , reach[i].out)) ) return reach[i].out;
    return 0;
}
int ox_play_tuyoi(LPOXGAME g, const char player)
{
    int xa, xb, m, xr, i;

    if(player == 'O') {
        xa = g->map_o; /* O プレイヤ優先*/
        xb = g->map_x;
    }

    if(player == 'X') {
        xa = g->map_x; /* X プレイヤ優先 */
        xb = g->map_o;
    }
    m = g->map_o | g->map_x;
    if(Match(m, (NO_0|NO_1|NO_2|
                 NO_3|NO_4|NO_5|
                 NO_6|NO_7|NO_8))) return 0; /* map full */

    /* リーチなら埋めて勝つ */
    if(xr = ox_is_reach(g, xa)) return xr;

    /* 敵リーチ 阻止 */
    if(xr = ox_is_reach(g, xb)) return xr;

   for(i = 0; pattern[i].out != 0; i++ )
    if( Match( xb , pattern[i].pat )
       && (!Match( m , pattern[i].out)) ) return pattern[i].out;

    return 0;
}

#pragma once
#include "Player.h"
class MoreBetterPlayer:public Player{//長さ３専用っていうか最適化しちゃった。。。
public:
    char*GetName(){ return "MoreBetterPlayer.";}
    void Play(MBGame& in){
        if(in.HasEmpty() && in.Length()>3) {
            while(in.SetStone(rand()%in.Length(),rand()%in.Length(),Mark_));
            return;
        }
        //マスの重み
        short Point[]={    31,26 ,31,
                        26,100,30,
                        31,27 ,32,
        };
        int op=0;
        think(in,Point,9);
        do{
            if(!in.HasEmpty()) return;
            for(int i=0;i<9;i++){
                if(Point[i] >Point[op]){
                    op=i;
                }
            }
            Point[op]=-30000;
        }while(!in.SetStone(op%3,op/3,Mark_));
        
    }
protected:
    
    void think(MBGame& in,short Point[],int N){
        const short Posi = 10;
        const short Nega = -10;
        const short danger =999;
        char Lines[8][3]={
                        {0,1,2},{3,4,5},{6,7,8},//横
                        {0,3,6},{1,4,7},{2,5,8},//縦
                        {0,4,8},{2,4,6},//斜め
        };
        char Corner[4] = {0,2,6,8};//角
        char Hole[4] = {1,3,5,7};//変の真ん中。
        char Line2[4][3] = { {0,1,2},{0,3,6},{6,7,8},{2,5,8},};//辺のライン
        char Line3[4][2] ={ {0,1},{0,3},{1,2},{2,3}};//ラインの組み合わせ。
        char Corner2[2][2]={{0,8},{2,6}};

        for(int i=0;i<2;i++){//死にパターンつぶし２。角とその対角にコマがおかれてしまったら、さらに別の角にコマを置かれて死んでしまう。
            Mark M1 = in.At(Corner2[i][0]);
            Mark M2 = in.At(Corner2[i][1]);
            if(M1 == M2 && M1 != Mark_ && M1!= None){
                for(int j=0;j<4;j++){
                    Point[Hole[i]]+= Posi;
                }
            }
        }
        for(int i=0;i<4;i++){//死にパターンつぶし。ある角で繋がっている二辺に一個ずつコマがあって、次その接点である角にコマをおかれると死んでしまう。
            int P=0;
            for(int j=0;j<2;j++){
                for(int k=0;k<3;k++){
                    int N = Line2[Line3[i][j]][k];
                    Mark M = in.At(N);
                    if(M == Mark_ ) P++;
                    if(M != Mark_ && M != None ) P--;    
                }
            }
            if(P <= -2) {
                Point[Corner[i]] += Posi;
            }
        }
        if(in.At(1,1) == Mark_){//真ん中を自分がとってる場合、敵の4隅の重要性はほぼ他のマスと同じなので急がなくてもよい。って考えた。
            for(int i=0;i<4;i++){
                Point[Corner[i]]+=Nega;
            }
        }
        for(int i=0;i<8;i++){//超危ない時の判定
            int P=0;
            int x=0,y=0;
            for(int j=0;j<3;j++){
                int N= Lines[i][j];
                Mark M = in.At(N);
                if(M == Mark_) P++;
                if(M != None && M != Mark_) P--;
            }
            for(int j=0;j<3;j++){
                if(P == 2) Point[Lines[i][j]]+=danger+100;
                if(P == -2) Point[Lines[i][j]]+=danger-100;
            }
        }
    }
};

wins={{1,2,3},{4,5,6},{7,8,9},{1,4,7},{2,5,8},{3,6,9},{1,5,9},{3,5,7}};

isWinner[player_]:=MemberQ[Length[Intersection[player,#]]&/@wins,3]

judge[{p1_,p2_}]:=
  If[isWinner@p1,1,
    If[isWinner@p2,-1,
      If[Length@p1==5,0,Null]]]

operators[state_]:=Complement[Range@9,Flatten@state]

game[decision1_,decision2_]:=Module[{state={{},{}},result=Null},
    While[result===Null,
      If[Length@state[[1]]==Length@state[[2]],
        AppendTo[state[[1]],decision1[Sort/@state]],
        AppendTo[state[[2]],decision2[Sort/@state]]];
      result=judge@state];
    result]

randomDecision[state_]:=With[{x=operators@state},
    x[[Random[Integer,{1,Length@x}]]]]

nextStates[{p1_,p2_},ops_]:=
  Map[If[Length@p1==Length@p2,
      {Append[p1,#],p2}&,{p1,Append[p2,#]}&],ops]

Remove[minimaxDecision];
minimaxDecision[s_]:=
  Module[{ops=operators@s,vals,isMax=Length@s[[1]]==Length@s[[2]]},
    vals=minimaxValue[#,Not@isMax]&/@nextStates[s,ops];
    minimaxDecision[s]=ops[[Position[vals,If[isMax,Max,Min]@vals][[1,1]]]]]

minimaxValue[state_,isMax_]:=Module[{result=judge@state},
    If[result=!=Null,result,
      If[isMax,Max,Min][
        minimaxValue[#,Not@isMax]&/@nextStates[state,operators@state]]]]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Drawing;
using Strategy = System.Func<System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.Drawing.Point, bool>>, bool, System.Drawing.Point>;
using Board = System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.Drawing.Point, bool>>;
using System.Diagnostics;

namespace DoukakuMarubatsu
{
    public static class Marubatsu
    {
        internal static void Start()
        {
            var strategySet = new[] 
            { 
                new Strategy [] { Aho, Aho },
                new Strategy [] { Aho, Kasikoi },
                new Strategy [] { Kasikoi, Aho },
                new Strategy [] { Kasikoi, Kasikoi },
            };

            foreach( var set in strategySet )
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                Debug.WriteLine( string.Format( "{0} {1}", set[ 0 ].Method.Name, set[ 1 ].Method.Name ) );
                foreach( var result in from i in Enumerable.Range( 1, 10000 )
                                       let result = Start( set[ 0 ], set[ 1 ] )
                                       let dummy = Console.WriteLine( i ) is object
                                       group result by result into g
                                       let count = g.Count()
                                       orderby count descending
                                       select new { result = g.Key.HasValue ? ( g.Key.Value ? set[ 0 ].Method.Name : set[ 1 ].Method.Name ) : "draw", count } )
                    Debug.WriteLine( result );
                Debug.WriteLine( sw.Elapsed );
            }

            Console.ReadLine();
        }

        static bool? Start( Strategy getNext1, Strategy getNext2 )
        {
            var board = new Dictionary<Point, bool>();
            return new[] { new { player = true, getNext = getNext1 }, new { player = false, getNext = getNext2 } }
                .Cycle()
                .Select( p =>
                {
                    board.Add( p.getNext( board, p.player ), p.player );
                    return GetWinner( board, p.player );
                } )
                .First( winner => winner.HasValue || board.Count == 9 );
        }

        static bool? GetWinner( Board board )
        {
            return GetWinner( board, true ) ?? GetWinner( board, false );
        }
        static bool? GetWinner( Board board, bool player )
        {
            Func<Func<int, Point>, bool> check = toPoint => new[] { 0, 1, 2 }.All( i => board.Any( p => p.Key == toPoint( i ) && p.Value == player ) );
            if( new[] { 0, 1, 2 }.Any( i => check( x => new Point( x, i ) ) || check( y => new Point( i, y ) ) )
                || check( i => new Point( i, i ) )
                || check( i => new Point( 2 - i, i ) ) )
                return player;
            else
                return null;
        }

        static IEnumerable<Point> EnumeratePoints()
        {
            foreach( var y in new[] { 0, 1, 2 } )
                foreach( var x in new[] { 0, 1, 2 } )
                    yield return new Point( x, y );
        }

        static void TraceBoard( Board board )
        {
            foreach( var p in EnumeratePoints() )
                Console.Write( ToMark( board.Contains( p ) ? (bool?)board.First( pp => pp.Key == p ).Value : null ) + ( p.X == 2 ? "\n" : "" ) );
            Console.WriteLine( "----" );
        }

        static string ToMark( bool? player )
        {
            return player.HasValue ? ( player.Value ? "○" : "×" ) : "□";
        }

        static Random _rnd = new Random();
        static Point Aho( Board board, bool player )
        {
            var putable = board.EnumeratePutable().ToArray();
            return putable[ _rnd.Next( putable.Length ) ];
        }

        #region kasikoi

        static Point Kasikoi( Board board, bool player )
        {
            {//本来は不要だが総当りの回数を減らすために決めうち
                    if( board.Count() == 0 ) return new Point( 1, 1 );
                if( board.Count() == 1 ) return !board.Contains( new Point( 1, 1 ) ) ? new Point( 1, 1 ) : new Point( 0, 0 );
                if( board.Count() == 2 ) return !board.Contains( new Point( 1, 1 ) ) ? new Point( 1, 1 )
                    : new[] { 0, 2 }.SelectMany( y => new[] { 0, 2 }.Select( x => new Point( x, y ) ) ).First( kado => !board.Contains( kado ) );
            }

            //b:boardPattern d:dictionary p:player/keyValuePair/point o:otherPlayer g:group c:candidate
            var candidates0 = ( from b in EnumeratePatterns( board, Enumerable.Empty<KeyValuePair<Point, bool>>(), player )
                                let d = board.Concat( b ).ToDictionary( p => p.Key, p => p.Value )
                                let winner = GetWinner( d )
                                let count = d.Count
                                group new { winner, count } by b.First().Key into g
                                let pMin = g.Min( c => c.winner == player ? c.count : 9 )
                                let oMin = g.Min( c => c.winner == !player ? c.count : 9 )
                                let pCnt = g.Count( c => c.winner == player )
                                let oCnt = g.Count( c => c.winner == !player )
                                orderby pCnt + ( oCnt == 0 ? 1000 : 0 ) descending
                                select new { point = g.Key, pMin, oMin } ).ToArray();

            var katimenasi = candidates0.All( c => c.pMin > c.oMin );
            var candidates = candidates0.Where( c => ( katimenasi || c.pMin <= c.oMin ) && CanPut( board, c.point, player ) );
            return candidates.Count() > 0 ? candidates.First().point : board.EnumeratePutable().First();
        }

        static bool CanPut( Board board, Point point, bool player )
        {
            var virtualBoard = board.Add( point, player );
            return virtualBoard.EnumeratePutable().All( otherPlayerPoint =>
            {
                var virtualBoard2 = virtualBoard.Add( otherPlayerPoint, !player );
                //相手が次の次で勝てるポイント一覧
                    var list = virtualBoard2.EnumeratePutable()
                    .Where( otherPlayerPoint2 => GetWinner( virtualBoard2.Add( otherPlayerPoint2, !player ), !player ) == !player );
                //相手が勝てるポイントが複数あってもそこに自分が置いて勝てるなら問題なし
                    return list.Count() < 2 || list.Any( p => GetWinner( virtualBoard2.Add( p, player ), player ) == player );
            } );
        }

        static IEnumerable<Board> EnumeratePatterns( Board board, Board points, bool player )
        {
            var putable = board.EnumeratePutable().Except( points.Select( pp => pp.Key ) );
            if( putable.Count() == 0 || GetWinner( board ).HasValue )
                yield return points;
            else
                foreach( var p in putable )
                    foreach( var points2 in EnumeratePatterns( board.Add( p, player ), points.Add( p, player ), !player ) )
                        yield return points2;
        }

        #endregion

        #region extension

        public static IEnumerable<Point> EnumeratePutable( this Board board )
        {
            return EnumeratePoints().Except( board.Select( pp => pp.Key ) );
        }

        public static Board Add( this Board board, Point p, bool player )
        {
            return board.Concat( Enumerable.Repeat( new KeyValuePair<Point, bool>( p, player ), 1 ) );
        }

        public static bool Contains( this Board board, Point point )
        {
            return board.Any( p => p.Key == point );
        }

        public static IEnumerable<T> Cycle<T>( this IEnumerable<T> src )
        {
            while( true )
                foreach( T t in src )
                    yield return t;
        }

        #endregion
    }
}