1004 四子连棋 未完成

1004 四子连棋

时间限制: 1 s

空间限制: 128000 KB

题目等级 : 黄金 Gold

题解

查看运行结果

题目描述 Description

在一个4*4的棋盘上摆放了14颗棋子,其中有7颗白色棋子,7颗黑色棋子,有两个空白地带,任何一颗黑白棋子都可以向上下左右四个方向移动到相邻的空格,这叫行棋一步,黑白双方交替走棋,任意一方可以先走,如果某个时刻使得任意一种颜色的棋子形成四个一线(包括斜线),这样的状态为目标棋局。

 
 

输入描述 Input Description

从文件中读入一个4*4的初始棋局,黑棋子用B表示,白棋子用W表示,空格地带用O表示。

输出描述 Output Description

用最少的步数移动到目标棋局的步数。

样例输入 Sample Input

BWBO
WBWB
BWBW
WBWO

样例输出 Sample Output

5

数据范围及提示 Data Size & Hint

hi

分类标签 Tags 点此展开

  1 #include<iostream>
  2 #include<cstdio>
  3 using namespace std;
  4 const int MAXN=10;
  5 int map[MAXN][MAXN];
  6 int vis[MAXN][MAXN][MAXN][MAXN];
  7 int kong1x,kong1y;
  8 int kong2x,kong2y;
  9 int hang[MAXN];// 储存每一行有多少个黑棋子
 10 int lie[MAXN];
 11 int leftdjx;//左对角线
 12 int rightdjx;// 右对角线
 13 int ans=0x7fffffff;
 14 int xx[5]={-1,+1,0,0};
 15 int yy[5]={0,0,-1,+1};
 16 int how;// 1表示应该走黑棋    2表示白棋
 17 void dfs(int k1x,int k1y,int k2x,int k2y,int step)
 18 {
 19     for(int i=1;i<=4;i++)
 20     {
 21         if(leftdjx==4||rightdjx==4||hang[i]==4||(hang[i]==0&&k1x!=i&&k2x!=i)||lie[i]==4||(lie[i]==0&&k1y!=i&&k2y!=i))
 22         {
 23             if(step<ans)
 24             ans=step;
 25             return ;
 26         }
 27     }
 28     if(step>ans)
 29     return;
 30     for(int i=0;i<4;i++)
 31     {
 32         int flag=0;
 33         int wx=k1x+xx[i];
 34         int wy=k1y+yy[i];
 35         if(((map[wx][wy]==how)||how==2)&&wx<=4&&wx>=1&&wy<=4&&wy>=1&&map[wx][wy]!=2&&vis[k1x][k1y][wx][wy]==0)
 36         {
 37             if(map[wx][wy]==1)
 38             how=0;
 39             else if(map[wx][wy]==0)
 40             how=1;
 41             if(map[wx][wy]==1)
 42             {
 43                 hang[k1x]++;
 44                 hang[wx]--;
 45                 lie[k1y]++;
 46                 lie[wy]--;
 47                 if(k1x==k1y)
 48                 leftdjx++;
 49                 if(k1x+k1y==5)
 50                 rightdjx++;
 51                 flag=1;
 52                 if(wx==wy)
 53                 leftdjx--;
 54                 if(wx+wy==5)
 55                 rightdjx--;
 56             }
 57             vis[k1x][k1y][wx][wy]=1;
 58             map[k1x][k1y]=map[wx][wy];
 59             map[wx][wy]=2;
 60             dfs(wx,wy,k2x,k2y,step+1);
 61             /*if(map[wx][wy]==1)
 62             how=0;
 63             else if(map[wx][wy]==0)
 64             how=1;*/
 65             vis[k1x][k1y][wx][wy]=0;
 66             map[wx][wy]=map[k1x][k1y];
 67             map[k1x][k1y]=2;
 68             if(flag==1)
 69             {
 70                 hang[k1x]--;
 71                 hang[wx]++;
 72                 lie[k1y]--;
 73                 lie[wy]++;
 74                 if(k1x==k1y)
 75                 leftdjx--;
 76                 if(k1x+k1y==5)
 77                 rightdjx--;
 78                 if(wx==wy)
 79                 leftdjx++;
 80                 if(wx+wy==5)
 81                 rightdjx++;
 82             }
 83         }
 84     }
 85     for(int i=0;i<4;i++)
 86     {
 87         int flag=0;
 88         int wx=k2x+xx[i];
 89         int wy=k2y+yy[i];
 90         if(((map[wx][wy]==how)||how==2)&&wx<=4&&wx>=1&&wy<=4&&wy>=1&&map[wx][wy]!=2&&vis[k2x][k2y][wx][wy]==0)
 91         {
 92             if(map[wx][wy]==1)
 93             how=0;
 94             else if(map[wx][wy]==0)
 95             how=1;
 96             if(map[wx][wy]==1)
 97             {
 98                 hang[k2x]++;
 99                 hang[wx]--;
100                 lie[k2y]++;
101                 lie[wy]--;
102                 if(k2x==k2y)
103                 leftdjx++;
104                 if(k2x+k2y==5)
105                 rightdjx++;
106                 flag=1;
107                 if(wx==wy)
108                 leftdjx--;
109                 if(wx+wy==5)
110                 rightdjx--;
111             }
112             vis[k2x][k2y][wx][wy]=1;
113             map[k2x][k2y]=map[wx][wy];
114             map[wx][wy]=2;
115             dfs(k1x,k1y,wx,wy,step+1);
116             /*if(map[wx][wy]==1)
117             how=0;
118             else if(map[wx][wy]==0)
119             how=1;*/
120             vis[k2x][k2y][wx][wy]=0;
121             map[wx][wy]=map[k2x][k2y];
122             map[k2x][k2y]=2;
123             if(flag==1)
124             {
125                 hang[k2x]--;
126                 hang[wx]++;
127                 lie[k2y]--;
128                 lie[wy]++;
129                 if(k2x==k2y)
130                 leftdjx--;
131                 if(k2x+k2y==5)
132                 rightdjx--;
133                 if(wx==wy)
134                 leftdjx++;
135                 if(wx+wy==5)
136                 rightdjx++;
137             }
138         }
139     }
140 }
141 int main()
142 {
143     for(int i=1;i<=4;i++)
144     {
145         for(int j=1;j<=4;j++)
146         {
147             char c;
148             cin>>c;
149             if(c==‘B‘)
150             {
151                 map[i][j]=1;// 黑色棋子
152                 hang[i]++;
153                 lie[j]++;
154                 if(i==j)leftdjx++;
155                 if(i+j==5)rightdjx++;
156             }
157             else if(c==‘W‘)
158             {
159                 map[i][j]=0;//白色棋子
160             }
161             else
162             {
163                 map[i][j]=2;
164                 if(kong1x==0&&kong1y==0)
165                 {
166                     kong1x=i;
167                     kong1y=j;
168                 }
169                 else
170                 {
171                     kong2x=i;
172                     kong2y=j;
173                 }
174             }
175         }
176     }
177     how=2;
178     dfs(kong1x,kong1y,kong2x,kong2y,0);
179     printf("%d",ans);
180     return 0;
181 }

时间: 2024-10-05 22:44:38

1004 四子连棋 未完成的相关文章

Codevs 1004 四子连棋

1004 四子连棋 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题目描述 Description 在一个4*4的棋盘上摆放了14颗棋子,其中有7颗白色棋子,7颗黑色棋子,有两个空白地带,任何一颗黑白棋子都可以向上下左右四个方向移动到相邻的空格,这叫行棋一步,黑白双方交替走棋,任意一方可以先走,如果某个时刻使得任意一种颜色的棋子形成四个一线(包括斜线),这样的状态为目标棋局. ● ○ ●   ○ ● ○ ● ● ○ ● ○ ○ ● ○   输入描述 Input

1004 四子连棋

1004 四子连棋 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题解 题目描述 Description 在一个4*4的棋盘上摆放了14颗棋子,其中有7颗白色棋子,7颗黑色棋子,有两个空白地带,任何一颗黑白棋子都可以向上下左右四个方向移动到相邻的空格,这叫行棋一步,黑白双方交替走棋,任意一方可以先走,如果某个时刻使得任意一种颜色的棋子形成四个一线(包括斜线),这样的状态为目标棋局. ● ○ ●   ○ ● ○ ● ● ○ ● ○ ○ ● ○   输入描述 In

codevs 1004 四子连棋 BFS、hash判重

004 四子连棋 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题目描述 Description 在一个4*4的棋盘上摆放了14颗棋子,其中有7颗白色棋子,7颗黑色棋子,有两个空白地带,任何一颗黑白棋子都可以向上下左右四个方向移动到相邻的空格,这叫行棋一步,黑白双方交替走棋,任意一方可以先走,如果某个时刻使得任意一种颜色的棋子形成四个一线(包括斜线),这样的状态为目标棋局. ● ○ ●   ○ ● ○ ● ● ○ ● ○ ○ ● ○   输入描述 Input

CODEVS——T 1004 四子连棋

http://codevs.cn/problem/1004/ 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题解 查看运行结果 题目描述 Description 在一个4*4的棋盘上摆放了14颗棋子,其中有7颗白色棋子,7颗黑色棋子,有两个空白地带,任何一颗黑白棋子都可以向上下左右四个方向移动到相邻的空格,这叫行棋一步,黑白双方交替走棋,任意一方可以先走,如果某个时刻使得任意一种颜色的棋子形成四个一线(包括斜线),这样的状态为目标棋局. ● ○ ●   ○ ●

Code[VS] 1004 四子连棋

[题意] 给定4*4的棋盘,每个位置上为"B"."W"或" ",表示黑棋.白棋或空格.定义目标棋局为有一行.一列或一条对角线上有相同颜色的四个子.黑白交替下,开始时任意一方先下,求最少多少步能达到目标棋局. [分析] 首先定义变量: 基本   q(1)wt[2][2]记录空格位置 (2)int p[4][4]记录值,黑棋存1,白棋存2,空格存0 哈希表 hash(1)long long data,存棋局的值,就是转化为10进制后存储 (2)nex

CODEVS 1004四子连棋

题目描述 Description 在一个4*4的棋盘上摆放了14颗棋子,其中有7颗白色棋子,7颗黑色棋子,有两个空白地带,任何一颗黑白棋子都可以向上下左右四个方向移动到相邻的空格,这叫行棋一步,黑白双方交替走棋,任意一方可以先走,如果某个时刻使得任意一种颜色的棋子形成四个一线(包括斜线),这样的状态为目标棋局. ● ○ ●   ○ ● ○ ● ● ○ ● ○ ○ ● ○   输入描述 Input Description 从文件中读入一个4*4的初始棋局,黑棋子用B表示,白棋子用W表示,空格地带用

宽度优先搜索 之 CODE[VS] 1004 四子连棋

/* bfs + hash判重 第一次接触“hash判重”(哈希函数是依据于取余),是一种很好的思想,不过也有小的瑕疵: hash判重: 棋盘表示:空(0),白(1),黑(2) 整个棋盘一共16个格子,可以看成3进制的16位数,将其转化为10进制数,找一个质数取余,利用余数的不同来给棋盘的状态判重. (用质数取余的原因:我不知道为什么用质数取余,但是<算法导论>以及其他地方都推荐用质数取余,应该不会错的...) 细心一下就会发现,这里面有问题: 定义用于取余的质数为y,需要取余的数集为x[],

【宽度优先搜索】神奇的状态压缩 CodeVs1004四子连棋

一.写在前面 其实这是一道大水题,而且还出在了数据最水的OJ上,所以实际上这题并没有什么难度.博主写这篇blog主要是想写下一个想法--状态压缩.状态压缩在记录.修改状态以及判重去重等方面有着极高的(←_←词穷了,诸位大致理解一下就好)效率.博主原本打算在blog介绍一种DP--状态压缩型动态规划,但动笔(键盘??)前,博主突然想起自己前些年写过的一道广搜题,当时在判重方面冥思苦想想出了一种类似状态压缩的方法,开心了好久,于是在此先抛砖引玉为状压DP做个铺垫. 二.题目 Description

迭代加深搜索[codevs1004 四子连棋]

迭代加深搜索 一.算法简介 迭代加深搜索是在速度上接近广度优先搜索,空间上和深度优先搜索相当的搜索方式.由于在使用过程中引入了深度优先搜索,所以也可以当作深度优先搜索的优化方案. 迭代加深搜索适用于当搜索深度没有明确上限的情况. 例如上图的一棵搜索树,在进行深度优先搜索前先规定好这次搜索的最大深度dep,当搜索到达dep却还没搜索到结果时回溯. 之后不断加大搜索深度,重新搜索,直到找到结果为止.虽然这样搜索次数会累计很多次,但每一次搜索的范围和下一次搜索的范围相比微不足道,所以整体搜索速度不会受