poj 1753 Flip Game (枚举 / 十六进制的位数)
2012-07-14 11:22
288 查看
转载请注明出处:優YoU http://user.qzone.qq.com/289065406/blog/1299076400
提示:翻转棋,可以建模为多叉树
本题难点有两个,一个就是不要以全黑(或全白)作为目标进行搜索,而是要把全黑(或全白)作为“根”,去搜索树叶,看看是否有 输入的棋盘状态。
另一个难点需要一点数学功底,就是要知道 树 的最大高度,这是“状态不存在”的判断标准
提示:其实每格棋子最多只可以翻转一次(实际是奇数次,但这没意义),只要其中一格重复翻了2次(不论是连续翻动还是不连翻动),那么它以及周边的棋子和没翻动时的状态是一致的,由此就可以确定这个棋盘最多只能走16步,最多只能有翻出2^16种状态
本题有两种思路:
一种是常规思路,枚举所有状态,直至找到目标状态,而且由于只需要输出该种状态所在树的深度,因此推荐BFS,比较快,但DFS也可以的。详细方法见代码1
另外一种思路比较有技巧性,由于是4*4棋盘,因此利用了十六进制数的位数,通过一系列位运算达到目标,详细方法见代码2
[cpp] view
plaincopy
/*代码一:DFS+Enum*/
//Memory Time
//240K 344MS
//本题只要求输出翻转的次数,因此BFS或DFS都适用
#include<iostream>
using namespace std;
bool chess[6][6]={false};//利用的只有中心的4x4
bool flag;
int step;
int r[]={-1,1,0,0,0};//便于翻棋操作
int c[]={0,0,-1,1,0};
bool judge_all(void)//判断“清一色”
{
int i,j;
for(i=1;i<5;i++)
for(j=1;j<5;j++)
if(chess[i][j]!=chess[1][1])
return false;
return true;
}
void flip(int row,int col)//翻棋
{
int i;
for(i=0;i<5;i++)
chess[row+r[i]][col+c[i]]=!chess[row+r[i]][col+c[i]];
return;
}
void dfs(int row,int col,int deep) //深搜的迭代回溯是重点,很容易混乱
{
if(deep==step)
{
flag=judge_all();
return;
}
if(flag||row==5)return;
flip(row,col); //翻棋
if(col<4)
dfs(row,col+1,deep+1);
else
dfs(row+1,1,deep+1);
flip(row,col); //不符合则翻回来
if(col<4)
dfs(row,col+1,deep);
else
dfs(row+1,1,deep);
return;
}
int main(void)
{
char temp;
int i,j;
for(i=1;i<5;i++)
for(j=1;j<5;j++)
{
cin>>temp;
if(temp=='b')
chess[i][j]=true;
}
for(step=0;step<=16;step++) //对每一步产生的可能性进行枚举
{ //至于为什么是16,考虑到4x4=16格,而每一格只有黑白两种情况,则全部的可能性为2^16
dfs(1,1,0);
if(flag)break;
}
if(flag)
cout<<step<<endl;
else
cout<<"Impossible"<<endl;
return 0;
}
==============华丽的分割线================
[cpp] view
plaincopy
/*代码二:BFS+Bit*/
//把矩阵看成一个16进制数
//每一行代表16进制数的一个字母(或数字),而每一个字母(或数字)又恰由4个二进制位数字0和1组成
//因此一个4x4矩阵是由16位0和1构成,是从 第0位 到 第15位
//如矩阵
// * * * * 从右到左分别为第 0, 1, 2, 3位
// % % % % 从右到左分别为第 4, 5, 6, 7位
// # # # # 从右到左分别为第 8, 9,10,11位
// @ @ @ @ 从右到左分别为第12,13,14,15位
//代表16进制数
// @@@@ #### %%%% ****
// 15 ← 0
// 将一个int的某位 取反 用该int与(0x1<<i)进行^操作。
#include<iostream>
struct unit
{
int x; //用int的末16位记录16个位置的信息
int rounds; //记录第几轮达到当前的状态
int i; //记录该状态是通过翻动哪个棋子得来的,以避免返回先前的状态
};
//flip函数是从a状态通过翻动第i个棋子到达b状态
void flip(unit a, int i, unit& b) //a是queue[p]的形参, 当前要翻动第i只棋子, b是queue[q]的引用
{
int x = i / 4, y = i % 4; //x、y为当前要翻动的第i只棋子所对应内节点的坐标(就是所翻动棋子的行x列y)
b.x = a.x; //即令queue[q].x=queue[p].x ,即q先复制p(前一步)的状态,再对q进行翻转(对p状态无影响)
b.x = ((b.x) ^ (0x1 << (i))); //将一个b.x的第i位 取反,其实就是把 第i只棋子 翻转
if (x > 0)
b.x = ((b.x) ^ (0x1 << (i - 4))); //把 第i只棋子 上面的棋子翻转,当且仅当棋子i不在第0行时执行
if (x < 3)
b.x = ((b.x) ^ (0x1 << (i + 4))); //把 第i只棋子 下面的棋子翻转,当且仅当棋子i不在第3行时执行
if (y > 0)
b.x = ((b.x) ^ (0x1 << (i - 1))); //把 第i只棋子 右面的棋子翻转,当且仅当棋子i不在第0列时执行
if (y < 3)
b.x = ((b.x) ^ (0x1 << (i + 1))); //把 第i只棋子 左面的棋子翻转,当且仅当棋子i不在第3列时执行
b.rounds = a.rounds + 1; //当前执行翻转棋子的次数
b.i = i; //记录当前翻转的是第i只棋子
return;
}
int main()
{
/*queue*/
unit queue[100000]; //queue是一个队列,记录所有状态
queue[0].x = 0; //初始化为16进制的0(16进制的0和10进制的0是一样的)
queue[0].i = -1;
queue[0].rounds = 0;
//judge used
bool used[100000]={false}; //used记录已经存在的状态
/*read in*/
char str[10];
for (int i = 0; i < 4; i++)
{
scanf("%s", str); //一次输入一行字符串str(串长为4),输4次
for (int j = 0; j < 4; j++)
if (str[j] == 'b')
queue[0].x = ((0x1 << (i * 4 + j)) | (queue[0].x)); //位运算,遇b该位置1
} // 0x1为16进制的1
int p = 0, q = 0; //p,q分别是队列的头尾指针
//其实queue[p].x代表每一步的翻转前状态,queue[q].x代表每一步的翻转后状态
while (!((queue[q].x == 0) || (queue[q].x == 0xFFFF))) //当16进制数queue[q].x 不为0(全0)或15(全1)时执行
{
for (int i = 0; i < 16; i++) //最多翻动16只棋子,i代表第i只棋子
{
if(queue[p].i==i) //若翻动当前棋子i的前一步所翻的棋子queue[p].i就是i,则跳过不翻动
continue;
q++; //尾指针后移一位,为新状态“开辟”新的记录空间
flip(queue[p], i, queue[q]);
if (used[queue[q].x]) //以棋盘的状态(一个16进制数)作为数组used的下标,对应的对象为true时说明这个状态已经出现过
q--; //在得到一个新状态的时候要检验之前时候存在这个状态,如果存在就把这个状态舍弃,即q--
//但是下一次循环则继续翻下一只棋子,与状态的舍弃无关,相当于本次所翻的棋子操作无效
else
used[queue[q].x]=true; //若该状态没有出现过,则记录该状态
if ((queue[q].x == 0) || (queue[q].x == 0xFFFF))break; //棋盘状态为全0或全1时跳出for,由于while的条件关系,自然也跳出while
}
if (p==q) //此条件为真时,当且仅当BFS到最后一层的最后一种状态时仍没有匹配的状态(全0或全1)
{ //简单来说,就是当搜索到最后一层时,程序通过条件结束for,而不是通过break
printf("Impossible"); //直至搜索结束,队列queue中都没有目标状态(此时为impossible)。
break;
}
p++; //头指针后移一位,把当前状态作为初始状态
}
if ((queue[q].x == 0) || (queue[q].x == 0xFFFF)) //这是为了隔离因"impossible"时跳出while的情况
printf("%d\n", queue[q].rounds);
return 0;
}
提示:翻转棋,可以建模为多叉树
本题难点有两个,一个就是不要以全黑(或全白)作为目标进行搜索,而是要把全黑(或全白)作为“根”,去搜索树叶,看看是否有 输入的棋盘状态。
另一个难点需要一点数学功底,就是要知道 树 的最大高度,这是“状态不存在”的判断标准
提示:其实每格棋子最多只可以翻转一次(实际是奇数次,但这没意义),只要其中一格重复翻了2次(不论是连续翻动还是不连翻动),那么它以及周边的棋子和没翻动时的状态是一致的,由此就可以确定这个棋盘最多只能走16步,最多只能有翻出2^16种状态
本题有两种思路:
一种是常规思路,枚举所有状态,直至找到目标状态,而且由于只需要输出该种状态所在树的深度,因此推荐BFS,比较快,但DFS也可以的。详细方法见代码1
另外一种思路比较有技巧性,由于是4*4棋盘,因此利用了十六进制数的位数,通过一系列位运算达到目标,详细方法见代码2
[cpp] view
plaincopy
/*代码一:DFS+Enum*/
//Memory Time
//240K 344MS
//本题只要求输出翻转的次数,因此BFS或DFS都适用
#include<iostream>
using namespace std;
bool chess[6][6]={false};//利用的只有中心的4x4
bool flag;
int step;
int r[]={-1,1,0,0,0};//便于翻棋操作
int c[]={0,0,-1,1,0};
bool judge_all(void)//判断“清一色”
{
int i,j;
for(i=1;i<5;i++)
for(j=1;j<5;j++)
if(chess[i][j]!=chess[1][1])
return false;
return true;
}
void flip(int row,int col)//翻棋
{
int i;
for(i=0;i<5;i++)
chess[row+r[i]][col+c[i]]=!chess[row+r[i]][col+c[i]];
return;
}
void dfs(int row,int col,int deep) //深搜的迭代回溯是重点,很容易混乱
{
if(deep==step)
{
flag=judge_all();
return;
}
if(flag||row==5)return;
flip(row,col); //翻棋
if(col<4)
dfs(row,col+1,deep+1);
else
dfs(row+1,1,deep+1);
flip(row,col); //不符合则翻回来
if(col<4)
dfs(row,col+1,deep);
else
dfs(row+1,1,deep);
return;
}
int main(void)
{
char temp;
int i,j;
for(i=1;i<5;i++)
for(j=1;j<5;j++)
{
cin>>temp;
if(temp=='b')
chess[i][j]=true;
}
for(step=0;step<=16;step++) //对每一步产生的可能性进行枚举
{ //至于为什么是16,考虑到4x4=16格,而每一格只有黑白两种情况,则全部的可能性为2^16
dfs(1,1,0);
if(flag)break;
}
if(flag)
cout<<step<<endl;
else
cout<<"Impossible"<<endl;
return 0;
}
==============华丽的分割线================
[cpp] view
plaincopy
/*代码二:BFS+Bit*/
//把矩阵看成一个16进制数
//每一行代表16进制数的一个字母(或数字),而每一个字母(或数字)又恰由4个二进制位数字0和1组成
//因此一个4x4矩阵是由16位0和1构成,是从 第0位 到 第15位
//如矩阵
// * * * * 从右到左分别为第 0, 1, 2, 3位
// % % % % 从右到左分别为第 4, 5, 6, 7位
// # # # # 从右到左分别为第 8, 9,10,11位
// @ @ @ @ 从右到左分别为第12,13,14,15位
//代表16进制数
// @@@@ #### %%%% ****
// 15 ← 0
// 将一个int的某位 取反 用该int与(0x1<<i)进行^操作。
#include<iostream>
struct unit
{
int x; //用int的末16位记录16个位置的信息
int rounds; //记录第几轮达到当前的状态
int i; //记录该状态是通过翻动哪个棋子得来的,以避免返回先前的状态
};
//flip函数是从a状态通过翻动第i个棋子到达b状态
void flip(unit a, int i, unit& b) //a是queue[p]的形参, 当前要翻动第i只棋子, b是queue[q]的引用
{
int x = i / 4, y = i % 4; //x、y为当前要翻动的第i只棋子所对应内节点的坐标(就是所翻动棋子的行x列y)
b.x = a.x; //即令queue[q].x=queue[p].x ,即q先复制p(前一步)的状态,再对q进行翻转(对p状态无影响)
b.x = ((b.x) ^ (0x1 << (i))); //将一个b.x的第i位 取反,其实就是把 第i只棋子 翻转
if (x > 0)
b.x = ((b.x) ^ (0x1 << (i - 4))); //把 第i只棋子 上面的棋子翻转,当且仅当棋子i不在第0行时执行
if (x < 3)
b.x = ((b.x) ^ (0x1 << (i + 4))); //把 第i只棋子 下面的棋子翻转,当且仅当棋子i不在第3行时执行
if (y > 0)
b.x = ((b.x) ^ (0x1 << (i - 1))); //把 第i只棋子 右面的棋子翻转,当且仅当棋子i不在第0列时执行
if (y < 3)
b.x = ((b.x) ^ (0x1 << (i + 1))); //把 第i只棋子 左面的棋子翻转,当且仅当棋子i不在第3列时执行
b.rounds = a.rounds + 1; //当前执行翻转棋子的次数
b.i = i; //记录当前翻转的是第i只棋子
return;
}
int main()
{
/*queue*/
unit queue[100000]; //queue是一个队列,记录所有状态
queue[0].x = 0; //初始化为16进制的0(16进制的0和10进制的0是一样的)
queue[0].i = -1;
queue[0].rounds = 0;
//judge used
bool used[100000]={false}; //used记录已经存在的状态
/*read in*/
char str[10];
for (int i = 0; i < 4; i++)
{
scanf("%s", str); //一次输入一行字符串str(串长为4),输4次
for (int j = 0; j < 4; j++)
if (str[j] == 'b')
queue[0].x = ((0x1 << (i * 4 + j)) | (queue[0].x)); //位运算,遇b该位置1
} // 0x1为16进制的1
int p = 0, q = 0; //p,q分别是队列的头尾指针
//其实queue[p].x代表每一步的翻转前状态,queue[q].x代表每一步的翻转后状态
while (!((queue[q].x == 0) || (queue[q].x == 0xFFFF))) //当16进制数queue[q].x 不为0(全0)或15(全1)时执行
{
for (int i = 0; i < 16; i++) //最多翻动16只棋子,i代表第i只棋子
{
if(queue[p].i==i) //若翻动当前棋子i的前一步所翻的棋子queue[p].i就是i,则跳过不翻动
continue;
q++; //尾指针后移一位,为新状态“开辟”新的记录空间
flip(queue[p], i, queue[q]);
if (used[queue[q].x]) //以棋盘的状态(一个16进制数)作为数组used的下标,对应的对象为true时说明这个状态已经出现过
q--; //在得到一个新状态的时候要检验之前时候存在这个状态,如果存在就把这个状态舍弃,即q--
//但是下一次循环则继续翻下一只棋子,与状态的舍弃无关,相当于本次所翻的棋子操作无效
else
used[queue[q].x]=true; //若该状态没有出现过,则记录该状态
if ((queue[q].x == 0) || (queue[q].x == 0xFFFF))break; //棋盘状态为全0或全1时跳出for,由于while的条件关系,自然也跳出while
}
if (p==q) //此条件为真时,当且仅当BFS到最后一层的最后一种状态时仍没有匹配的状态(全0或全1)
{ //简单来说,就是当搜索到最后一层时,程序通过条件结束for,而不是通过break
printf("Impossible"); //直至搜索结束,队列queue中都没有目标状态(此时为impossible)。
break;
}
p++; //头指针后移一位,把当前状态作为初始状态
}
if ((queue[q].x == 0) || (queue[q].x == 0xFFFF)) //这是为了隔离因"impossible"时跳出while的情况
printf("%d\n", queue[q].rounds);
return 0;
}
相关文章推荐
- POJ 1753 Flip Game(dfs+枚举)
- poj 1753 Flip Game(枚举,bfs)(简单)
- POJ - 1753 Flip Game(枚举+反转)
- POJ-1753 Flip Game 枚举 状态压缩
- 枚举状态POJ1753-Flip Game(枚举)
- POJ1753,Flip Game,枚举,bfs都可以
- POJ 1753 Flip Game 高斯消元 枚举自由变量
- POJ 1753 Flip Game (枚举)
- poj1753--Flip Game(高斯消元问题2,枚举自由元的首杀)
- POJ 1753 Flip Game 枚举
- Flip Game(poj1753_阵列的枚举)
- POJ1753 Flip Game(翻转问题且纯枚举暴力翻转)
- poj_1753 Flip Game(dfs+枚举)/(bfs+位运算)
- poj 1753 Flip Game(枚举)
- POJ 1753 Flip Game (枚举)
- POJ 1753 Flip Game(枚举)
- POJ 1753 Flip Game 翻转(枚举+dfs)
- POJ 1753 Flip Game(高斯消元法,枚举自由变元)
- poj 1753 Flip Game(枚举)
- POJ 1753 Flip Game(枚举+dfs)