对对棋，可能大家都没有听说过。对对棋是本人发明的棋，并将其实现于电脑上。
下载地址：http://www.
1.对对棋规则
一开局是N*N的棋盘（N可以在“设置”中进行设置），棋盘两旁有棋子，左边白右边黑，各N个。白棋先行，谁将对方棋子全部推入棋盘四周的水中，谁就算赢。
（1）加号与减号
棋子有属性笑口常开和感动常在，一开始时都是1和1。当一个棋子甲和另一个棋子乙靠在一起时，如果甲的笑口常开程度≥乙及乙后方棋子的感动常在程度之和，那么甲就可以推动乙及乙身后的棋子。当然，乙后面也可以没有棋子。
笑口常开和感动常在可以通过两种方式增加。一是在棋盘上捡到，二是从商店购买。
一开局时，棋盘上会随机摆放上一个加号和一个减号，让棋子移动到加号上，那么棋子的笑口常开程度就会加1；让棋子移动到减号上，那么棋子的感动常在程度就会加1。
一开局，双方每人100￥，点击一个棋子，程序窗口上就会出现一个商店按钮，点它，可以买东西。50￥一个加号，100￥一个减号。钱用掉就没有了，不能增加。
（2）眩晕
当一颗棋子推动了一排棋子，那么被推动的棋子将会眩晕，持续一回合。当棋子眩晕时，它是不能自己移动的，但是可以被其它棋子推动。
棋子刚被推时，眩晕程度是2，接着该对方下，眩晕程度变为1，再该对方下，眩晕程度再变为0，此时该棋子不眩晕。
2.AI输入格式（输入文件：ai.in）
第一行，两个整数。第一个整数代表是否可以买加号，第二个整数代表是否可以买减号。1代表可以，0代表不可以。
第二行，四个整数。第一个数N（4≤N≤10），棋盘边长（不包括水，即中间草地部分），第二个数代表现在该谁下，即您的AI要代表的是黑棋还是白棋。白棋是1，黑棋是0。第三个数是白棋钱数，第四个数是黑棋钱数。
接下来一行五个数，直到一行5个0时停止，每一行代表一个白棋子。第一个数是棋子的列数，第二个数是行数，第三个数是眩晕程度，第四个数是笑口常开程度，第五个数是感动常在程度。
接下来又是一行五个数，直到一行5个0时停止，每一行代表一个黑棋子。
接下来一行两个数，直到一行2个0时停止，每一行代表一个加号。第一个数是加号的列数，第二个数是行数。
接下来一行两个数，直到一行2个0时停止，每一行代表一个减号。第一个数是减号的列数，第二个数是行数。（虽然棋盘上最多只有1个加号1个减号，但还是这样的文件输入格式比较好）
3.AI输出格式 （输出文件： ai.out）
第一行，要移动棋子的列数。
第二行，要移动棋子的行数。
第三行，进行的操作。向前移动写F，向后移动写B，向左移动写L，向右移动写R，给它买加号写Jia，给它买减号写Jian。
4.样例
【输入】
1 1
5 1 50 100
1 4 0 1 1
2 3 0 1 1
3 3 0 2 1
3 4 0 1 1
0 0 0 0 0
3 1 0 1 1
4 2 0 1 1
5 2 0 1 1
5 3 0 1 1
0 0 0 0 0
2 1
0 0
2 5
0 0
【输出】
1
4
R
【输入解释】
是如图的棋盘
http://hiphotos.baidu.com/vfleaking/pic/item/e496841c39e2b7a51ad576c6.jpg
【输出解释】
第一列第四个向右移动一格。或许您的AI有更好的走法，您不必非要下这一步棋。
5.编写AI的注意事项
1.对对棋需要的是一个可执行文件，不需要您的AI源代码，也就是说，您可以用任何语言实现对对棋AI。
2.您的AI必须在30秒内给出答案。
3.您的AI必须走有效地棋步，不然会被判输。
4.您的AI可以放在磁盘的任意地方，只要在对对棋的“游戏”-“设置”中提供您AI的位置。
6.对对棋AI比赛
比赛报名结束时间为2月7日，再此之前您可以把您的AI发送到 vfleaking@，请注明您的网名。比赛将于2月7日晚上进行，使用5*5的棋盘，可以买加减，结果将于比赛结束后揭晓。这次比赛是我个人举行的，就当是娱乐娱乐。有意者请与我联络，谢谢！


[ 本帖最后由 VFleaKing 于 2011-2-2 10:11 编辑 ]

可能这个AI是太复杂了

#include <stdio.h>
#define MaxN 10

#define Grass 0
#define A 1
#define B 2
#define Jia 3
#define Jian 4
#define Water 5
         
#define PriceJia 50
#define PriceJian 100
         
#define Win 1
#define Lost 2
#define CannotMove 3
#define None 4
         
#define Front 1
#define Back 2
#define Left 3
#define Right 4
#define BuyJia 5
#define BuyJian 6
int depth;
int bestX, bestY, bestFs;
int ys;
int UseJia, UseJian;
int Xua [MaxN + 2][MaxN + 2] = {0},
    Hap [MaxN + 2][MaxN + 2] = {0},
    Alw [MaxN + 2][MaxN + 2] = {0},
    What[MaxN + 2][MaxN + 2] = {0};
int N;
int Who;
int MoneyA, MoneyB;
int MoveX[100], MoveY[100], MoveFs[100], MoveLen = 0;

int min(int a, int b)
{
    return a < b ? a : b;
}
int GetValue()
{
    int value = 0, meMaxHappy = 0, meMaxMoved = 0,
        otherMaxHappy = 0, otherMaxMoved = 0,
        meMoney = 0, otherMoney = 0;
    int i, j;
    for (i = 1; i <= N; i++)
    {
        for (j = 1; j <= N; j++)
        {
            if (What[i][j] == A || What[i][j] == B)
            {
                int temp = min(i, j);
                temp = min(temp, N - i + 1);
                temp = min(temp, N - j + 1);
                if (What[i][j] == ys)
                {
                    value += temp + 10;
                    if (Xua[i][j] == 0)
                    {
                        if (Hap[i][j] > meMaxHappy)
                            meMaxHappy = Hap[i][j];
                        if (Alw[i][j] > meMaxMoved)
                            meMaxMoved = Alw[i][j];
                    }
                }
                else
                {
                    value -= temp + 10;
                    if (Xua[i][j] == 0)
                    {
                        if (Hap[i][j] > otherMaxHappy)
                            otherMaxHappy = Hap[i][j];
                        if (Alw[i][j] > otherMaxMoved)
                            otherMaxMoved = Alw[i][j];
                    }
                }
            }
        }
    }
    switch (ys)
    {
        case A:
            meMoney = MoneyA;
            otherMoney = MoneyB;
            break;
        case B:
            meMoney = MoneyB;
            otherMoney = MoneyA;
            break;
    }
    if (meMaxHappy < otherMaxMoved)
        value -= 100;
    if (otherMaxHappy < meMaxMoved)
        value += 100;
    if (meMaxHappy + meMoney / PriceJia < otherMaxMoved + otherMoney / PriceJian)
        value -= 200;
    if (otherMaxHappy + otherMoney / PriceJia < meMaxMoved + meMoney / PriceJian)
        value += 200;
    return value;
}

int TimePass(int y)
{
    int itFind = 0, otherFind = 0, itCanMove = 0;
    int i, j;
    for (i = 1; i <= N; i++)
    {
        for (j = 1; j <= N; j++)
            if ((What[i][j] == A || What[i][j] == B) && Xua[i][j] != 0)
                Xua[i][j]--;
    }

    for (i = 1; i <= N; i++)
    {
        for (j = 1; j <= N; j++)
        {
            if (What[i][j] == A || What[i][j] == B)
            {
                if (What[i][j] == y)
                {
                    itFind = 1;
                    if (Xua[i][j] == 0)
                        itCanMove = 1;
                }

                if (What[i][j] == A + B - y)
                    otherFind = 1;
            }
        }
    }
    if (!itFind)
        return Lost;
    if (!otherFind)
        return Win;
    if (!itCanMove)
        return CannotMove;
    return None;
}

int Not(int mfs)
{
    switch (mfs)
    {
        case Front:
            return Back;
        case Back:
            return Front;
        case Left:
            return Right;
        case Right:
            return Left;
    }
}

int GetX(int x, int mfs)
{
    switch (mfs)
    {
        case Front:
        case Back:
            return x;
        case Left:
            return x - 1;
        case Right:
            return x + 1;
    }
}

int GetY(int y, int mfs)
{
    switch (mfs)
    {
        case Front:
            return y - 1;
        case Back:
            return y + 1;
        case Left:
        case Right:
            return y;
    }
}

void Move(int x, int y, int mfs, int mmove)
{
    MoveLen = 0;
    if (!(What[x][y] == A || What[x][y] == B))
        return;
    int fbX = x, fbY = y;
    if (Front <= mfs && mfs <= Right)
    {
        int notMfs = Not(mfs);
        int can = 0;
       
        int sumHap = 0;
        while (sumHap <= Hap[fbX][fbY])
        {
            x = GetX(x, mfs);
            y = GetY(y, mfs);
            if (What[x][y] == A || What[x][y] == B)
            {
                sumHap += Alw[x][y];
                if (sumHap > Hap[fbX][fbY])
                    return;
            }
            else
            {
                can = 1;
                break;
            }
        }
        if (!can)
        {
            x = GetX(x, mfs);
            y = GetY(y, mfs);
            if (What[x][y] == A || What[x][y] == B)
                return;
        }
        int tempX = x, tempY = y;
        x = GetX(x, notMfs);
        y = GetY(y, notMfs);
        if (What[tempX][tempY] != Water && mmove)
        {
            Xua [tempX][tempY] = Xua [x][y];
            Hap [tempX][tempY] = Hap [x][y];
            Alw [tempX][tempY] = Alw [x][y];
            What[tempX][tempY] = What[x][y];
            if (What[tempX][tempY] == Jia)
                Hap[tempX][tempY]++;
            else if (What[tempX][tempY] == Jian)
                Xua[tempX][tempY]++;
        }
        MoveX [MoveLen] = x;
        MoveY [MoveLen] = y;
        MoveFs[MoveLen] = mfs;
        MoveLen++;
        if (x != fbX || y != fbY)
        {
            for (x = GetX(x, notMfs), y = GetY(y, notMfs);
                 GetX(x, mfs) != fbX || GetY(y, mfs) != fbY;
                 x = GetX(x, notMfs), y = GetY(y, notMfs))
            {
                tempX = GetX(x, mfs);
                tempY = GetY(y, mfs);
                if (mmove)
                {
                    Xua [tempX][tempY] = Xua [x][y];
                    Hap [tempX][tempY] = Hap [x][y];
                    Alw [tempX][tempY] = Alw [x][y];
                    What[tempX][tempY] = What[x][y];
                }
                MoveX [MoveLen] = x;
                MoveY [MoveLen] = y;
                MoveFs[MoveLen] = mfs;
                MoveLen++;
            }
        }
        if (mmove)
            What[fbX][fbY] = Grass;
    }
    else if (mfs == BuyJia)
    {
        switch (Who)
        {
            case A:
                if (MoneyA >= PriceJia && UseJia)
                {
                    MoveX [MoveLen] = x;
                    MoveY [MoveLen] = y;
                    MoveFs[MoveLen] = mfs;
                    MoveLen++;
                    if (mmove)
                    {
                        Hap[x][y]++;
                        MoneyA -= PriceJia;
                    }
                }
                else
                    return;
                break;
            case B:
                if (MoneyB >= PriceJia && UseJia)
                {
                    MoveX [MoveLen] = x;
                    MoveY [MoveLen] = y;
                    MoveFs[MoveLen] = mfs;
                    MoveLen++;
                    if (mmove)
                    {
                        Hap[x][y]++;
                        MoneyB -= PriceJia;
                    }
                }
                else
                    return;
                break;
        }
    }
    else if (mfs == BuyJian)
    {
        switch (Who)
        {
            case A:
                if (MoneyA >= PriceJian && UseJian)
                {
                    MoveX [MoveLen] = x;
                    MoveY [MoveLen] = y;
                    MoveFs[MoveLen] = mfs;
                    MoveLen++;
                    if (mmove)
                    {
                        Hap[x][y]++;
                        MoneyA -= PriceJian;
                    }
                }
                else
                    return;
                break;
            case B:
                if (MoneyB >= PriceJian && UseJian)
                {
                    MoveX [MoveLen] = x;
                    MoveY [MoveLen] = y;
                    MoveFs[MoveLen] = mfs;
                    MoveLen++;
                    if (mmove)
                    {
                        Hap[x][y]++;
                        MoneyB -= PriceJian;
                    }
                }
                else
                    return;
                break;
        }
    }
}

int CanKillOurs(int x, int y, int mfs)
{
    if (Front <= mfs && mfs <= Right)
    {
        if (What[x][y] != A && What[x][y] != B)
            return 0;
        while (What[x][y] == A || What[x][y] == B)
        {
            x = GetX(x, mfs);
            y = GetY(y, mfs);
        }
        if (What[x][y] == Water && What[GetX(x, Not(mfs))][GetY(y, Not(mfs))] == Who)
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

int CleverThink(int depthNow, int alpha, int beta)
{
    if (depthNow == 0)
        return GetValue();
    if (depthNow != depth * 2)
    {
        Who = A + B - Who;
        switch (TimePass(Who))
        {
            case Win:
                if (ys == Who)
                    return -1000 * depthNow;
                else
                    return 1000 * depthNow;
            case Lost:
                if (ys == Who)
                    return 1000 * depthNow;
                else
                    return -1000 * depthNow;
            case CannotMove:
                    return -CleverThink(depthNow - 1, -beta, -alpha);
        }
    }
   
    int fbXua [MaxN + 2][MaxN + 2] = {0},
        fbHap [MaxN + 2][MaxN + 2] = {0},
        fbAlw [MaxN + 2][MaxN + 2] = {0},
        fbWhat[MaxN + 2][MaxN + 2] = {0},
        fbWho, fbMoneyA, fbMoneyB;
    int i, j, k, l, fs;
    for (i = 0; i <= N + 1; i++)
    {
        for (j = 0; j <= N + 1; j++)
        {
            fbXua [i][j] = Xua [i][j];
            fbHap [i][j] = Hap [i][j];
            fbAlw [i][j] = Alw [i][j];
            fbWhat[i][j] = What[i][j];
        }
    }
    fbWho = Who;
    fbMoneyA = MoneyA;
    fbMoneyB = MoneyB;
    for (i = 1; i <= N; i++)
    {
        for (j = 1; j <= N; j++)
        {
            if (What[i][j] == Who && Xua[i][j] == 0)
            {
                for (fs = Front; fs <= BuyJian; fs++)
                {
                    Move(i, j, fs, 0);
                    if (MoveLen > 0 && !CanKillOurs(i, j, fs))
                    {
                        if (Front <= fs && fs <= Right)
                        {
                            for (k = 0; k < MoveLen - 1; k++)
                                Xua[MoveX[k]][MoveY[k]] = 2;
                        }
                        Move(i, j, fs, 1);
                        int value = -CleverThink(depthNow - 1, -beta, -alpha);
                        for (k = 0; k <= N + 1; k++)
                        {
                            for (l = 0; l <= N + 1; l++)
                            {
                                Xua [k][l] = fbXua [k][l];
                                Hap [k][l] = fbHap [k][l];
                                Alw [k][l] = fbAlw [k][l];
                                What[k][l] = fbWhat[k][l];
                            }
                        }
                        Who = fbWho;
                        MoneyA = fbMoneyA;
                        MoneyB = fbMoneyB;
                        if (value >= beta && beta != -2147483647)
                            return value;
                        if (value > alpha)
                        {
                            alpha = value;
                            if (depth * 2 == depthNow)
                            {
                                bestX = i;
                                bestY = j;
                                bestFs = fs;
                            }
                        }
                    }
                }
            }
        }
    }
    return alpha;
}

int main()
{
    freopen("ai.in", "r", stdin);
    freopen("ai.out", "w", stdout);
   
    int i;
    scanf("%d %d", &UseJia, &UseJian);
    scanf("%d %d %d %d", &N, &Who, &MoneyA, &MoneyB);
   
    int x, y, xuanyun, happiness, alwaysMoved;
    do
    {
        scanf("%d %d %d %d %d", &x, &y, &xuanyun, &happiness, &alwaysMoved);
        Xua[x][y]  = xuanyun;
        Hap[x][y]  = happiness;
        Alw[x][y]  = alwaysMoved;
        What[x][y] = A;
    }
    while (x != 0);
    do
    {
        scanf("%d %d %d %d %d", &x, &y, &xuanyun, &happiness, &alwaysMoved);
        Xua[x][y]  = xuanyun;
        Hap[x][y]  = happiness;
        Alw[x][y]  = alwaysMoved;
        What[x][y] = B;
    }
    while (x != 0);
    do
    {
        scanf("%d %d", &x, &y);
        What[x][y] = Jia;
    }
    while (x != 0);
    do
    {
        scanf("%d %d", &x, &y);
        What[x][y] = Jian;
    }
    while (x != 0);
   
    for (i = 0; i <= N + 1; i++)
    {
        What[0    ][i    ] = Water;
        What[i    ][0    ] = Water;
        What[N + 1][i    ] = Water;
        What[i    ][N + 1] = Water;
    }
    ys = Who;
    depth = 3;
    CleverThink(depth * 2, -2147483647, 2147483647);
    printf("%d\n", bestX);
    printf("%d\n", bestY);
    switch (bestFs)
    {
        case Front:
            printf("F");
            break;
        case Back:
            printf("B");
            break;
        case Left:
            printf("L");
            break;
        case Right:
            printf("R");
            break;
        case BuyJia:
            printf("Jia");
            break;
        case BuyJian:
            printf("Jian");
    }
    printf("\n");
    return 0;
}

我写的AI，没加注释

似乎这次比赛进行得不够理想，结贴算了

很有可能，因为这个本来是C++代码，改了半天改成了C，估计有地方打错了。