围棋要实现什么功能呢?

首先是黑棋和白棋,下面的代码,黑棋占领的位置被赋值为1,白棋是2;

其次有几个围棋中的规则(不知道是不是这样的,老师是这么告诉我的,可以指正):1.块:上下左右可以连起来的叫块,一颗棋上下左右四个方向若有棋子,就可以称作是一块,一个棋子上下左右都没有,也可以称作一块。2.气:就是一个块周围(上下左右)都没有棋的地方,那就是气。

那么要实现什么呢?就是每下一次棋,返回一方所有的块和每一块有多少气。如果没气了,就把围住的棋都取走(数组里就是清为0)。


 

先来看看主函数

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#define maxsize 10

#define null 0

typedef struct node{

       int x;

       int y;

       struct node*next;

} lqnode;

typedef struct{

       node *front,*rear;

}Queue;

 //定义了两个结构体,一个是队列,一个是节点

int main(){
int chess[10][10];
int savechess[10][10];//设置了一个数组保存之前下个棋盘
int i,j,type=1,a,b,flag=0;
for(i=0;i<10;i++){
  for(j=0;j<10;j++){
    chess[i][j]=0;
  }
}

for(i=0;i<10;i++){
  for(j=0;j<10;j++){
    printf(” %d”,chess[i][j]);
  }
  printf(“\n”);
}

printf(“黑手:”);

//执黑子先手
while(scanf(“%d %d”,&a,&b)!=EOF){

  //输入一方要下的位置
  if(flag==0){
    type=1;//黑方是1
    flag=1;
  }else{
    type=2;//白方是2
    flag=0;
  }

//利用以上实现黑方白方切换
  chess[a][b]=type;//下棋

//保存之前的棋盘
 for(int i=0;i<10;i++){
    for(int j=0;j<10;j++){
      savechess[i][j]=chess[i][j];
    }
  }

  lumpgas(chess,type);

//把所有七七八八的放在一个函数里,传入的参数现在的棋盘,以及现在是哪一方下棋,因为传入的数组会在函数里发生改变,所以上面的savechess就是为了保存。

//赋值,更新现在的棋盘
  for(int i=0;i<10;i++){
    for(int j=0;j<10;j++){
      if(chess[i][j]==9 ||chess[i][j]==6 ||chess[i][j]==3){//为什么是这个条件,下面看lumpgas再解释
       chess[i][j]=savechess[i][j];

      }
    }
  }
//输出下过之后的棋盘
  for(i=0;i<10;i++){
    for(j=0;j<10;j++){
      printf(” %d”,chess[i][j]);
     }
    printf(“\n”);
  }

//如果上面是黑棋,那下一个就是白棋下辣!
  if(type==1){
    printf(“白手\n”);
  }else{
    printf(“黑手\n”);
  }
}
return 0;

}


现在就来看看lumpgas函数里实现的功能

void lumpgas(int chess[10][10],int type){

       int total=0;//这个是用来标记的,下面看看怎么退出循环

       int twtype=type*3;//这也是用来标记下面是否循环过

       while(total==0){//为什么是循环呢,就是说每一方可能不止只有一个块

       Queue *q;

       lqnode *p;

       q=(Queue *)malloc(sizeof(Queue));

       p=(lqnode *)malloc(sizeof(lqnode));

       p->next=null;

       q->rear=p;

       q->front=p;

       int x=0,y=0,flag=1;

 //下面就用黑方为例来讲解吧,先找到黑方的第一个占领的位置

       for(int i=0;i<10;i++){

              for(int j=0;j<10;j++){

                     if(chess[i][j]==type && flag==1){

                            x=i;

                            y=j;

                            flag=0;//因为是二维,所以用这个方法来记录下标

                     }

              }

       

             

       }

      

      chess[x][y]=type*3;//用来记录这个点已经找过了,以便于下一次循环找其他的块

 

        lqnode *r,*t;

        r=(lqnode *)malloc(sizeof(lqnode));

        r->x=x;

        r->y=y;

        q->rear->next=r;

        r->next=null;

        q->rear=r;

 //进队列

        

       t=q->front->next;

       x=t->x;

       y=t->y;

      

int num=0;    

 

while(num!=4){

         num=4;//这个是循环的条件,如果说这个节点上下左右都没有可以进入队列的节点了就退出

      //以下是广度优先来找连在一起的点,找到就进队列,上下左右都找

    if(chess[x-1][y]==type){

            

        r=(lqnode *)malloc(sizeof(lqnode));

        r->x=x;

        r->y=y+1;

        q->rear->next=r;

        r->next=null;

        q->rear=r;

        chess[x-1][y]=twtype;//标记一下这个地方已经找过了

        num–;

              }

             

             

                           

        if(chess[x+1][y]==type){

              r=(lqnode *)malloc(sizeof(lqnode));

        r->x=x+1;

        r->y=y;

        q->rear->next=r;

        r->next=null;

        q->rear=r;

        chess[x+1][y]=twtype;

        num–;

              }

             

        if(chess[x][y-1]==type){

             r=(lqnode *)malloc(sizeof(lqnode));

        r->x=x;

        r->y=y-1;

        q->rear->next=r;

        r->next=null;

        q->rear=r;

        chess[x][y-1]=twtype;

        num–;

              }

             

             

      

        if(chess[x][y+1]==type){

             r=(lqnode *)malloc(sizeof(lqnode));

        r->x=x;

        r->y=y+1;

        q->rear->next=r;

        r->next=null;

        q->rear=r;

        chess[x][y+1]=twtype;

        num–;

              }

       if(num==4){

              break;再判断一遍,找不到就退出

       }

       t=t->next;

       x=t->x;

       y=t->y;

       printf(“%d,%d\n”,x,y);

}

 

t=q->front->next;//先记录一下这个头

       int count=0;

       printf(“该块有以下元素:\n”);

    while(q->rear!=q->front){

             lqnode *s;

             s=q->front->next;

             x=s->x;

             y=s->y;

     //上下左右都找一遍,注意条件,有些在边上,比如【0】【0】这个点x-1是找不到的

             if(chess[x+1][y]==0 && x+1>=0 && y>=0){

                     count++;

                            chess[x+1][y]=9;     //找过的标记一下,以防再找一遍                         

             }

                     if(chess[x][y+1]==0 && x>=0 && y+1>=0) {

                     count++;

                     chess[x][y+1]=9;

             }

                    if(chess[x][y-1]==0 && x>=0 && y-1>=0) {

                     count++;

                     chess[x][y-1]=9;

             }

                    if(chess[x-1][y]==0 && x-1>=0 && y>=0) {

                     count++;

                           chess[x-1][y]=9;

             }

            

             q->front->next=s->next;          

             printf(“x=%d,y=%d\n”,x,y);

            //出队列喽

             if(s->next==null){

                    q->rear=q->front;

             }

        }

 

printf(“该块有%d口气\n”,count);

 

if(count==0){//如果为0,就是被对方围住啦,里面所有的都要变为0,就是里面的棋子都要被拿走

       while(t!=null){//这个就是上面那个t为什么要被记录下来的原因

              x=t->x;

              y=t->y;

              chess[x][y]=0;

              t=t->next;

       }

      

}

//以下就是再循环,找到没有被记录过并且还是黑放下的棋的点,

x=-1;

y=-1;

flag=1;

 

              for(int i=0;i<10;i++){

              for(int j=0;j<10;j++){

                     if(chess[i][j]==type && flag==1){//因为之前被找过的已经记录过了

                            x=i;

                            y=j;

                            flag=0;

                     }

              }

}

       if(x==-1&&y==-1){

              total=1;//如果找不到就是退出循环辣

       }

       }

      

}

 最后再解释一下

for(int i=0;i<10;i++){

              for(int j=0;j<10;j++){

                     if(chess[i][j]==9 ||chess[i][j]==6 ||chess[i][j]==3)

                     {chess[i][j]=savechess[i][j];}

                    

              }

       }

      这一部分。

因为在lumpgas()函数里有记录的痕迹,所以要把记录的点都变成以前的,然后就是说一定要有记录,因为当一方的棋被围住了,所有被围住的棋都是要清掉的,清掉这个功能也是在函数里实现的

 

原文地址:http://www.cnblogs.com/mdddd-yep/p/16830044.html

1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长! 2. 分享目的仅供大家学习和交流,请务用于商业用途! 3. 如果你也有好源码或者教程,可以到用户中心发布,分享有积分奖励和额外收入! 4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解! 5. 如有链接无法下载、失效或广告,请联系管理员处理! 6. 本站资源售价只是赞助,收取费用仅维持本站的日常运营所需! 7. 如遇到加密压缩包,默认解压密码为"gltf",如遇到无法解压的请联系管理员! 8. 因为资源和程序源码均为可复制品,所以不支持任何理由的退款兑现,请斟酌后支付下载 声明:如果标题没有注明"已测试"或者"测试可用"等字样的资源源码均未经过站长测试.特别注意没有标注的源码不保证任何可用性