数据结构设计--五子棋程序对弈

最新推荐文章于 2024-02-24 17:00:00 发布
最新推荐文章于 2024-02-24 17:00:00 发布
阅读量993 收藏 20
点赞数 7
分类专栏： 算法 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72747430/article/details/128881672
版权

目录

1.课题要求

2.思路

3.源代码

手敲800多行代码,搞了6个小时，终于写完了五子棋博弈问题，艰难！(以下纯属个人思路,仅供参考，创作不易，禁止搬运)

希望对大家有帮助。

1.课题要求

还记得我们在第一章 见过的“人机对弈”那个例子吗?现在就请你利用自己所学的知识，设计一一个“ 五子棋”对弈程序吧。注意:你所设计的‘对弈程序”的对手是人，因此你的“对弈程序”也要具有一定的智能:能赢就绝不平局，最差的结果也就是平局。要求:

(1)当用户执子时，需在界面上输入落棋的位置。

(2) 当用户落子后，“对弈程序”在两秒后给出落子位置。

(3) 每当一方落子后，要刷新棋盘状态。

(4)棋盘大小为15*15。

2.思路

又加了一个人-人PK。

(1)判断输赢,只可能在当前落子的位置判断输赢

(2)电脑所要执行的操作:

a.当用户已经构成3子的时候,此时电脑必须拦截用户所下的第4个棋子的

落子位置,如果拦截失败,用户在某种意义上面已经取得胜利,只需要走

接下来的操作即可,此时用户胜利;如果拦截成功,则继续游戏，但是还有

一种情况,当用户连成3子的话,此时电脑已经连成3子了,此时电脑下连成

3子的位置.

b.如果用户没有构成3子的话,电脑可以走自己的步数,一次搜索有没有构

成4个棋子的,如果有,则落下此棋子;如果没有4个棋子的,再搜索有没有

3个棋子,...,择优进行选择,能赢一定赢.

c.当落满整个棋盘上面的棋子的时候,和局.

3.源代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<stdlib.h>
using namespace std;
const int N=1100;

string mp[N][N];//棋盘
int st[N][N];//标记
int n,m;//棋盘大小
bool vis[N][N];

void menu()//菜单
{
    printf("**********欢迎来到五子棋小游戏**********\n");
    printf("**********     1.人-机PK    ***********\n");
    printf("**********     2.人-人PK    ***********\n");
    printf("**********     3.退出       ***********\n");
    printf("***************************************\n");
}

int search(int x,int y,int dx[],int dy[],int ans,int op)//搜索连成几个棋子
{
    for(int i=1;i<=4;i++)
    {
        int l=x+dx[i],r=y+dy[i];
        if(l>=1&&l<=n&&r>=1&&r<=m&&st[l][r]==op) ans++;
        else break;
    }
    return ans;
}

bool check(int x,int y,int op)//判断输赢,只可能在当前落子的位置判断输赢
{
    int ans;
    int dx[5],dy[5];

    //正对角线
    ans=1;
    for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=-i;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;
    for(int i=1;i<=4;i++) dx[i]=i,dy[i]=i;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;

    //反对角线
    ans=1;
    for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=i;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;
    for(int i=1;i<=4;i++) dx[i]=i,dy[i]=-i;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;

    //横向
    ans=1;
    for(int i=1;i<=4;i++) dx[i]=0,dy[i]=-i;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;
    for(int i=1;i<=4;i++) dx[i]=0,dy[i]=i;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;

    //纵向
    ans=1;
    for(int i=1;i<=4;i++) dx[i]=i,dy[i]=0;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;
    for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=0;
    ans=search(x,y,dx,dy,ans,op);
    if(ans>=5) return true;

    return false;
}

bool check2()//判断是否和局
{
    int ans=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(st[i][j]) ans++;
    if(ans==n*m) return true;//已经落满所有的位置
    return false;
}

void init()//初始化棋盘
{
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            mp[i][j]="#";
}

void print()//打印棋盘
{
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=m;j++)
        {
            if(i==0&&j!=0) 
            {
                cout<<j<<" ";
            }
            else if(i!=0&&j==0) 
            {
                cout<<i<<" ";
            }
            else if(i==0&&j==0) cout<<"  ";
            else cout<<mp[i][j]<<" ";
        }
        puts("");
    }
}

void print2(int f)//显示黑白棋子
{
    if(f==1) cout<<"(黑子):";
    else cout<<"(白子):";
}

void check3(int f,int &a,int &b)//电脑检测落子的位置
{
    //寻找电脑是否连成3子
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(st[i][j]==3-f)//如果是电脑下的棋子
            {
                int ans;
                int dx[5],dy[5];
                //正对角
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l--,r--;
                    if(l&&r&&!st[l][r]&&st[l-1][r-1]!=f&&l-1&&r-1) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l++,r++;
                    if(l&&r&&!st[l][r]&&st[l+1][r+1]!=f&&l+1<=n&&r+1<=m) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }

                //反对角线
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l--,r++;
                    if(l&&r&&!st[l][r]&&st[l-1][r+1]!=f&&l-1>=1&&r+1<=m) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l++,r--;
                   if(l&&r&&!st[l][r]&&st[l+1][r-1]!=f&&l+1<=n&&r-1) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }

                //横向
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=0,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3) 
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) r--;
                    if(l&&r&&!st[l][r]&&st[l][r-1]!=f&&r-1) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=0,dy[i]=i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]&&l>=1&&l<=n&&r>=1&&r<=m&&!vis[l][r]) r++;
                    if(l&&r&&!st[l][r]&&st[l][r+1]!=f&&r+1<=m) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                } 

                //纵向
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=0;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3) 
                {
                    int l=i,r=j;
                    while(st[l][r]&&l>=1&&l<=n&&r>=1&&r<=m) l++;
                    if(l&&r&&!st[l][r]&&st[l+1][r]!=f&&l+1<=n) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=0;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=3)
                {
                     int l=i,r=j;
                    while(st[l][r]&&l>=1&&l<=n&&r>=1&&r<=m) l--;
                    if(l&&r&&!st[l][r]&&st[l-1][r]!=f&&l) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }  
            }
        }
    }

    //拦截用户
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(st[i][j]==f)//如果是用户下的棋子
            {
                int ans;
                int dx[5],dy[5];
                //正对角
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) l--,r--;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=i;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) l++,r++;
                    if(l&&r&&!st[l][r]&&!vis[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }

                //反对角线
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=i;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) l--,r++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) l++,r--;
                   if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }

                //横向
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=0,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3) 
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) r--;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=0,dy[i]=i;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3)
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) r++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                } 

                //纵向
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=0;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3) 
                {
                    int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) l++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=0;
                ans=search(i,j,dx,dy,ans,f);
                if(ans>=3)
                {
                     int l=i,r=j;
                    while(st[l][r]==f&&l>=1&&l<=n&&r>=1&&r<=m) l--;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }              
            }
        }
    }

    //都没有拦截的话
    for(int k=2;k>=1;k--)
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(st[i][j]==3-f)//如果是电脑下的棋子
            {
                int ans;
                int dx[5],dy[5];
                //正对角
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l--,r--;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l++,r++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }

                //反对角线
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l--,r++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l++,r--;
                   if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }

                //横向
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=0,dy[i]=-i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k) 
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) r--;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=0,dy[i]=i;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k)
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) r++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                } 

                //纵向
                ans=1;
                for(int i=1;i<=4;i++) dx[i]=i,dy[i]=0;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k) 
                {
                    int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l++;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }
                for(int i=1;i<=4;i++) dx[i]=-i,dy[i]=0;
                ans=search(i,j,dx,dy,ans,3-f);
                if(ans>=k)
                {
                     int l=i,r=j;
                    while(st[l][r]==3-f&&l>=1&&l<=n&&r>=1&&r<=m) l--;
                    if(l&&r&&!st[l][r]) 
                    {
                        st[l][r]=3-f;
                        if(3-f==1) mp[l][r]="○";//黑子
                        else if(3-f==2) mp[l][r]="●";//白子
                        a=l,b=r;
                        return ;
                    }
                }  
            }
        }
    }

    //白子为空
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(!st[i][j])
            {
                st[i][j]=3-f;
                if(3-f==1) mp[i][j]="○";//黑子
                else if(3-f==2) mp[i][j]="●";//白子
                a=i,b=j;
                return ;
            }
}

void game1()//人-机PK
{
    init();

    int f;
    cout<<"***1.黑子***"<<endl;
    cout<<"***2.白子***"<<endl;
    cout<<"请用户选择一个棋子的颜色:";
    while(1)
    {
        cin>>f;
        if(f==1||f==2) break;
        else cout<<"序号错误!请重新选择:";
    }
    //此时用户选择的一定是1或者2,那么电脑的选择为3-f

    memset(vis,false,sizeof vis);

    while(1)
    {
        system("cls");
        print();
        int x,y;
        cout<<"请用户选择一个坐标";
        print2(f);
        while(1)
        {
            cin>>x>>y;
            if(st[x][y]) 
            {
                cout<<"该位置已落子,请用户重新输入:";
                print2(f);
            }
            else 
            {
                st[x][y]=f;
                if(f==1) mp[x][y]="○";//黑子○
                else mp[x][y]="●";//白子

                if(check(x,y,f)) 
                {
                    system("cls");
                    print();
                    cout<<"用户取得胜利!"<<endl;
                    return ;
                }
                break;
            }
        }
        system("cls");
        print();
        _sleep(1000);//延时1s
        /*电脑所要执行的操作:
            1.当用户已经构成3子的时候,此时电脑必须拦截用户所下的第4个棋子的
              落子位置,如果拦截失败,用户在某种意义上面已经取得胜利,只需要走
              接下来的操作即可,此时用户胜利;如果拦截成功,则继续游戏，但是还有
              一种情况,当用户连成3子的话,此时电脑已经连成3子了,此时电脑下连成
              3子的位置.
            2.如果用户没有构成3子的话,电脑可以走自己的步数,一次搜索有没有构
              成4个棋子的,如果有,则落下此棋子;如果没有4个棋子的,再搜索有没有
              3个棋子,...,择优进行选择,能赢一定赢.
            3.当落满整个棋盘上面的棋子的时候,和局.*/
        int a,b;
        check3(f,a,b);
        if(check(a,b,3-f)) 
        {
            system("cls");
            print();
            cout<<"很遗憾,电脑获胜!"<<endl;
            return ;
        }
        if(check2())//落满所有的棋子时--平局
        {
            cout<<"您和电脑平局!"<<endl;
            return ;
        }
    }
}

void game2()//人-人PK
{
    init();

    //st==1标记黑子,st==2标记白子
    int f=2;
    
    while(1)
    {
        system("cls");
        print();
        if(f%2==0)
        {
            int x,y;
            cout<<"请您选择一个坐标(黑子):";
            while(1)
            {
                cin>>x>>y;
                if(st[x][y]) cout<<"该位置已落子,请您重新输入(黑子):";
                else 
                {
                    st[x][y]=1;
                    mp[x][y]="○";//黑子○
                    if(check(x,y,1)) 
                    {
                        system("cls");
                        print();
                        cout<<"黑子胜!"<<endl;
                        return ;
                    }
                    break;
                }
            }
        }
        else
        {
            int x,y;
            cout<<"请您选择一个坐标(白子):";
            while(1)
            {
                cin>>x>>y;
                if(st[x][y]) cout<<"该位置已落子,请您重新输入(白子):";
                else 
                {
                    st[x][y]=2;
                    mp[x][y]="●";//白子
                    if(check(x,y,2)) 
                    {
                        system("cls");
                        print();
                        cout<<"白子胜!"<<endl;
                        return ;
                    }
                    break;
                }
            }
        }
        if(check2())
        {
            cout<<"黑白棋子平局!"<<endl;
            return ;
        }
        f++;
        if(f==4) f=2;
    }
}

int main()
{
    while(1)
    {
        memset(st,0,sizeof st);
        m=9,n=9;
        menu();
        int op;
        printf("请选择一个模式：");
        cin>>op;
        switch (op)
        {
            case 1:game1();break;
            case 2:game2();break;
            case 3:printf("感谢您的使用！");return 0;break;
            default:cout<<"序号错误,请重新输入!"<<endl;break;
        }
    }
}

电脑判定用户落子还需要完善，这个程序只是拦截简单的用户落子，用户很容易取胜，后期会加强电脑检测用户落子的位置，代码也会更新。

 

梦·源·启
关注
  • 7
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Restful+JQuery的五子棋对战游戏开发
Aaron_Yang
03-06 4732
一、实验设计方案 实验名称：快乐五子棋项目 1、实验目的： 1)通过本学期所学的知识完成期末综合大作业，实现五子棋对战项目的开发，包括四个部分：用户的注册、登录、个人信息、用户管理、登出；五子棋游戏棋局的创建与对弈；玩家观战；对战棋局的录像播放。 2)利用jQuery编写网页前端，用restfuleasy框架进行后台处理，使用DM数据库储存数据，进行前后台之间的数据交互。 3)熟练掌握所学的知识，前后端的交互、restful技术和jquery、ajax、websocket通信，java知识和数据库知识，以及
【Unity】五子棋AI博弈算法实讲
Leibnezz的博客
02-21 1870
系统的，分层次的讲解了五子棋AI博弈算法。
让电脑变得更聪明——用python实现五子棋游戏
weixin_55939638的博客
09-23 8661
让电脑变得更聪明——用python实现五子棋游戏
五子棋（人人博弈和人机博弈的Java实现）
SJYsjydsb的博客
09-09 1317
机器方AI类的定义，该类中使用到的数据结构有两个Map，分别为AttackMap，其中存放的是进攻棋型，以及棋型对应的权值；DefendMap存放的是防守棋型，以及棋型对应的权值。清空权值矩阵，判断是否是Ai的回合，获取一个点的所有棋链(即进攻棋链和防御棋链)。5、棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。简单来说，如果想两个类共享一个属性，这个属性必须是引用类型，不能是基本数据类型。空白交叉的的权值，然后Ai会下在权值最大的位置。主类FiveChess。
运用博弈树实现五子棋人机对战
qq_52771580的博客
07-22 2096
一、构建博弈树 当轮到机器落子时，程序调用主函数,树的深度n=0，代表以当前局势为整个博弈树根结点，深度为0；同时在棋盘上没有落子的地方依次调用creatNode函数，在creatNode函数内部，n首先加一，n代表当前节点的深度，创建孩子结点（即当n为奇数时在棋盘上没有棋子的所有地方分别假设机器下一个子，当n为偶数时在棋盘上没有棋子的所有地方分别假设玩家下一个子，每个地方假设下子后的局势代表一个孩子节点）。对所有孩子结点依次进行判断，若孩子节点代表的棋局没分出胜负且深度没有达到指定深度，...
Java中的“五子棋”游戏程序
08-10
在Java编程语言中，开发一个"五子棋"游戏程序是一项有趣的挑战，它涉及到基本的控制结构、数据类型以及对象的交互。以下是对这个程序的关键知识点的详细解释： 1. **基本数据类型与数组**： - 在`FiveChessGame`类...
C++语言设计实现五子棋
12-26
本文为大家分享了C++五子棋的设计思路和设计实现，供大家参考，具体内容如下 算法思路： 在结束了对C++的学习之后，...数据存储：五子棋棋盘为15*15的网格结构，即一共有225个节点，每个节点有横竖坐标各一，同时每个
程序设计课程设计（五子棋）
10-16
总的来说，这个五子棋项目不仅锻炼了开发者的基础编程技能，还涉及到了图形界面设计、游戏规则实现、数据结构、算法以及人工智能等多个方面的知识，对于学习和理解面向对象程序设计以及MFC编程有极大的帮助。
五子棋设计思想
01-07
在设计五子棋程序时，首先需要考虑的是数据结构。一个关键的变量是棋盘的二维数组Table，用于存储棋子的状态，'0'代表空位，'1'代表己方棋子，'2'代表对方棋子。此外，为了评估棋局，还需要创建两个三维数组Computer...
五子棋人机对弈（C++）
06-24
这里设计了一个简单的五子棋程序，采用对空格点进行评分排序的算法（C++语言描述）。 总的来说（我们假定您熟悉五子棋的基本规则），要让电脑知道该在哪一点下子，就要根据盘面的形势，为每一可能落子的点计算其重要...
数据结构课程设计-五子棋.
10-27
别人学校的数据结构课程设计 关于五子棋的 pdf自行转换
C数据结构课程设计人机，网络，双人对战20*20五子棋游戏源码（包含课程设计文档)
09-08
用C语言写的一个数据结构课程设计，该程序实现了20*20棋盘大小的五子棋人工智能对战游戏程序，支持网络对战、支持双人游戏、支持棋局录制与重放，还有音乐播放功能 。（最重要的是包含课程设计文档，和程序的源代码）。
五子棋——人机博弈（Java实现）
weixin_53068616的博客
12-10 6616
1引言 本文档是考试系统项目的内容汇总，其主要内容包括： 项目说明 需求分析 项目设计 编码与实现 测试说明 课程设计体会与总结 2项目说明 2.1项目要求 五子棋是全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成五子连线者获胜。具体要求如下： 功能需求： 1、实现人与人对决。 2、实现人与机器对决，对局双方各执一色棋子，要求其中一方为机器。 3、游戏开始要求为空棋盘。 4、黑先、白后，交替下子，每
DFS以JAVA方式实现例题详解
qq_40258899的博客
10-16 553
LeetCode求根到叶子节点数字之和 解题思路 使用DFS深度优先搜索进行遍历，然后遍历时将值进行累加。 递归方式实现BFS public class TreeNode {//节点定义 int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } int res =
MFC设计局域网对战五子棋游戏（五）游戏中的数据结构和算法
上善若水的专栏
04-13 2985
游戏中设计的结构体有：   //棋盘中每个格子的信息 typedef struct dot{ UINT used :1;//是否已经被占用 UINT uid :7;//占用者的id号 UINT lt :3;//左上角有几个相同id号的棋子 UINT t :3;//上方有几个相同id号的棋子 UINT rt :3;//以下根据方向不同表示意思类似 UINT l :3;//字段
毕业设计：基于深度学习的五子棋博弈系统
最新发布
2301_79555157的博客
02-24 2098
毕业设计：基于深度学习的五子棋博弈系统采用卷积神经网络（CNN）和循环神经网络（RNN）等深度学习技术，通过大量的自我对弈数据来训练和优化模型。首先介绍了系统的整体架构和关键技术，然后详细阐述了数据预处理、模型训练、对弈策略等关键步骤。通过实验验证，该系统表现出了较高的棋艺水平和良好的自我学习能力。这一研究为计算机毕业设计提供了一个创新的方向，结合了深度学习和博弈论，为毕业生提供了一个有意义的研究课题。
计算机五子棋博弈发展历史,五子棋计算机博弈系统的研究与设计
weixin_30164615的博客
07-21 559
摘要：计算机博弈是人工智能领域最具挑战的研究分支之一.它是研究人脑思维的载体,是计算机技术与博弈论相结合的产物,是人工智能领域的"试验田",被誉为人工智能的"果蝇".因此,有关计算机博弈的理论与实践研究,将可以促进人工智能的发展.在计算机博弈中,棋类博弈是其研究热点之一,因为人们相信存在于棋类博弈中的智能信息或许可以应用到人类智能活动中. 五子棋博弈是棋类博弈中至关重要的组成部分,其普及程度仅次...
博弈算法实现简单五子棋
方品
12-21 9091
博弈算法实现的简单五子棋，使用极大极小搜索，alpha-beta剪枝，java图形界面。
基于java的五子棋博弈系统
敷衍zgf的博客
02-09 3997
基于java的五子棋博弈系统 前言 本文是以学校Java面向对象程序设计课程设计要求为背景，利用了Java语言、人工智能算法知识和Eclipse IDE开发平台，开发了五子棋小游戏，本论文论述了五子棋小游戏的概念、结构、基本思路和方法，全文共分为绪论、设计分析、详细分析、设计结果及分析、总结和展望、参考文献以及附录（代码）等。 设计目的 巩固加深对java语言课程基本知识的理解和掌握； 掌握java语言编程和调试的基本技能； 掌握javaGUI编程的基本能力； 掌握JDK、WindowBuilder等开发
HTML5游戏设计-五子棋
09-12
1. 游戏规则设计：确保您了解五子棋的基本规则，并根据需要进行适当调整。包括棋盘大小、胜负条件、禁手规则等。 2. 图形界面设计：使用HTML5的Canvas元素来创建游戏界面。您可以设计一个棋盘背景，并使用不同颜色...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值