POJ1753 状态压缩（+BFS） + 棋盘问题

最新推荐文章于 2020-08-19 09:45:22 发布
最新推荐文章于 2020-08-19 09:45:22 发布
阅读量1.6k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a272846945/article/details/51892875
本文探讨了一种棋盘翻转问题，目标是最少次数将棋盘颜色统一。通过状态压缩结合BFS、DFS等算法实现解决方案，并提供了多种实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

0

棋盘问题，改变一个子的颜色，这个子以及这个子周围的四个位置（左右上下）的子分别变色，求最少的改变次数。

此类题大部分应该可以用状态压缩+暴力搜索解决。纯粹找规律不太合理。

 

1)第一种方法，状态压缩后BFS暴力搜索。因为棋盘很小，只有16个格子，枚举所有的状态共有2^16=65536种。所以有可以用int数组存储65535个状态用以确认哪一个出现了哪一个没出现，然后暴力枚举+BFS的搜索方式。

2)第二种，或者不进行状态压缩，直接按顺序，确定改变次数为1、改变次数为2...改变次数为16，在每一个确定的改变次数下用DFS求解。（直接DFS是从1到16一条路走到头然后不断回溯，第一次得到的颜色统一的改变次数未必是最小次数，所以改用有些BFS思想的DFS，但因为没有像BFS那样存储状态，所以做了一些重复的工作，时间会比第一种方法慢。）

 

 

3)WA，还未调试出来：

因为意识到解题的关键是，每一位置的子改变一次和改变两次其实是一样的&&改变第a个子然后改变第b个子的效果等同于先改变第b个子然后改变第a个子即与顺序无关，所以我设想不用状态压缩，直接按顺序只改变当前子之后的子不断BFS枚举，自然而然就可以避免重复的搜索工作。具体是指，第一轮，依次改变棋盘上第一个、第二个、第十六个子，共十六种情况存入队列，然后第二轮，从队列中取出改变第一个子后的状态，依次尝试改变第一个子往后的子，改变之后存入队列...第x轮，从队列中取出队首即上一轮中改变第m个子后的状态，那么我们只需考虑接下来改变第m个子之后的子即可，而不用考虑改变第m个子之前的子，因为那种情况相当于先改变第m个子之前的子此时改变第m个子。

我觉得我的思想应该没问题，起到的效果是等同于状态压缩中记录状态的作用的...不过就是没AC，样例过，疑问！？

 

1

1)

AC代码：

#include <iostream>
#include <queue>
#include <string.h>

using namespace std;
//int mmap[5][5]={0};
int dir[5][2]={{-1,0},{1,0},{0,-1},{0,1},{0,0}};
int visted[65536]={0};
int state[16];
int ini_state;
int flag;
int step;

struct boards{
    int state;
    int step;
};
queue<struct boards> q;
void initialize(){//☆这里可以打表
    int temp;
    int x,y;
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            temp=0;
            for(int l=0;l<5;l++){
                x=i+dir[l][0];
                y=j+dir[l][1];
                if(x<1||x>4||y<1||y>4){
                    continue;
                }
                temp^=(1<<( (x-1)*4+y -1 ));
            }
            state[(i-1)*4+j-1]=temp;
        }
    }
}
void Bfs(){
    struct boards cur_board;
    cur_board.state=ini_state;
    cur_board.step=0;
    q.push(cur_board);
    visted[cur_board.state]=1;
    while(!q.empty()){
        cur_board=q.front();
        q.pop();
        if(cur_board.state==0||cur_board.state==65535){
            step=cur_board.step;
            flag=1;
            return ;
        }
        struct boards next_board;
        for(int i=0;i<16;i++){
            next_board.state=cur_board.state^state[i];//☆这里可以马上判断一步，如果颜色统一立即return
            if(!visted[next_board.state]){
                next_board.step=cur_board.step+1;
                q.push(next_board);
                visted[next_board.state]=1;
            }
        }
    }
    return ;
}
int main(){
    ///initial
    ini_state=0;
    flag=0;
    step=0;
    char check;
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            cin>>check;
            if(check=='b')
                ini_state+=(1<< ( (i-1)*4+j - 1) );
            //cin>>mmap[i][j];
        }
    }
    //cout<<ini_state<<endl;
    initialize();//16 states of while board when only the piece was placed on the board.
    //for(int i=0;i<=15;i++){ cout<<state[i]<<endl;}


    ///bfs
    Bfs();


    ///result
    if(flag)
        cout<<step<<endl;
    else{
        cout<<"Impossible"<<endl;
    }
}


2)

AC代码：

#include <iostream>
#include <string.h>

using namespace std;
int mmap[5][5];
int dir[5][2]={{0,-1},{-1,0},{0,1},{1,0},{0,0}};//左 上 右 下 中
//int dir[5][5]={{-1,0},{1,0},{0,-1},{0,1},{0,0}};
int sum;
int flag=0;
int Judge(){
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            if(mmap[i][j]!=mmap[1][1]){
                return 0;
            }
        }
    }
    return 1;
}

void flip(int x,int y){
    for(int i=0;i<=4;i++){
        int x_next=x+dir[i][0];
        int y_next=y+dir[i][1];
        if(1<=x_next&&x_next<=4&&1<=y_next&&y_next<=4){
            mmap[x_next][y_next]=!mmap[x_next][y_next];
        }
    }
}

void Dfs(int x,int y,int obj,int cur_step){

    if(cur_step==obj){
       flag=Judge();
       return;
    }

    if(flag||x==5){
        return ;
    }

    flip(x,y);
/*
    if(y<4){
        Dfs(x,y+1,obj,cur_step+1);
    }
    else{
        Dfs(x+1,1,obj,cur_step+1);
    }
*/

    if(y+1<=4&&x<=4)
        Dfs(x,y+1,obj,cur_step+1);
    else if(y==4){
        Dfs(x+1,1,obj,cur_step+1);//不能写else if(y==4&&x+1<=4)因为判断函数（当cur_step==obj在dfs函数的开头，所以每一次翻转棋子之后，都应该调用dfs让其判断一次，如果因为x、y分别是最后一行最后一列了，因为x+1>4&&y==4而没有能进dfs直接把棋子翻转回来，return回到上一层，是不公平的，相当于这一轮对于最后一行最后一列的棋子翻转后没有进行判断是否是统一颜色了！！）
    }



    flip(x,y);//一定注意！不用bfs，而是dfs，每次改变的东西当return回来之后一定要状态还原！
/*
    if(y<4){
        Dfs(x,y+1,obj,cur_step);
    }
    else{
        Dfs(x+1,1,obj,cur_step);
    }
*/

    if(y+1<=4&&x<=4)
        Dfs(x,y+1,obj,cur_step);
    else if(y==4){
        Dfs(x+1,1,obj,cur_step);
    }


    return ;
}

int main(){
    memset(mmap,0,sizeof(mmap));
    char check;
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            cin>>check;
            if(check=='b'){
                mmap[i][j]=1;//b 1,w 0
            }
        }
    }
    int step=0;//当前翻转棋子个数
    for(int l=0;l<=16;l++){//应该翻转的棋子个数
       Dfs(1,1,l,step);
        if(flag==1){
            cout<<l<<endl;
            break;
        }
        if(l==16){
            cout<<"Impossible";
        }
    }
    return 0;
}


3)

WA代码第一份：

#include <iostream>
#include <queue>

using namespace std;
int sum;
int temp=0;
struct boards{
    char chess[4][4];
    int sum;
    int x_past;
    int y_past;
};
int dir[4][4]={{0,-1},{-1,0},{0,1},{1,0}};//左上右下
 queue <struct boards> q;
int Judge(struct boards boards_judge){

    char now=boards_judge.chess[0][0];
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            if(boards_judge.chess[i][j]!=now){
                return 0;
            }
        }
    }
    return 1;
}

int Reserve(){
    struct boards boards_cur;
    struct boards boards_future;
    if(q.empty()) return -1;
    boards_cur =q.front();

    q.pop();
    for(int i=boards_cur.x_past;i<4;i++){
        for(int j=boards_cur.y_past;j<4;j++){
            int x=i,y=j;
            if(x<0||x>3||y<0||y>3) continue;
            if(x==boards_cur.x_past&&y==boards_cur.y_past) continue;

            boards_future=boards_cur; //可以直接赋值
            boards_future.sum=boards_cur.sum+1;
            boards_future.x_past=i;
            boards_future.y_past=j;
            //cout<<"note:"<<boards_cur.sum<<endl;

            if(boards_cur.chess[i][j]=='b'){
                boards_future.chess[i][j]='w';
            }
            else{
                boards_future.chess[i][j]='b';
            }
            for(int l=0;l<4;l++){
                x=i+dir[l][0];
                y=j+dir[l][1];
                if(x<0||x>3||y<0||y>3) continue;
                if(boards_cur.chess[x][y]=='b'){
                    boards_future.chess[x][y]='w';
                }
                else{
                    boards_future.chess[x][y]='b';
                }
            }

            if(Judge(boards_future)){
                sum=boards_future.sum;
                return 1;
            }
            q.push(boards_future);
            //boards_cur.sum--;//！假如没有boards_future,直接q.push(boards_cur)，然后再对boards_cur操作，是否，放入队列的就不再受影响----是的！不受影响

        }
    }
    return 0;
}
int main()
{
    struct boards board;
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            cin>>board.chess[i][j];
        }
    }
    board.sum=0;
    sum=0;
    board.x_past=-1;
    board.y_past=-1;
    q.push(board);
    if(Judge(board)){
    }
    else{
        while(1){//0-Lost 1-Win
            //temp+=1;
            int state=Reserve();
            if(state==1){
                break;
            }
            if(state==-1){
                sum=-1;
                break;
            }
        }
    }
    if(sum!=-1)
        cout<<sum<<endl;
    else{
        cout<<"Impossible"<<endl;
    }
}

 


WA代码第二份

#include <iostream>
#include <string.h>

using namespace std;
int mmap[4][4];
int dir[5][2]={{0,-1},{-1,0},{0,1},{1,0},{0,0}};//左 上 右 下 中
int sum;
int flag=0;
int Judge(){

    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            if(mmap[i][j]!=mmap[1][1]){
                return 0;
            }
        }
    }
    return 1;
}
void flip(int x,int y){
    for(int i=0;i<=4;i++){
        int x_next=x+dir[i][0];
        int y_next=y+dir[i][1];
        if(0<=x_next&&x_next<=3&&0<=y_next&&y_next<=3){
            mmap[x_next][y_next]=!mmap[x_next][y_next];
        }
    }
}
void Dfs(int x,int y,int obj,int cur_step){
     if(flag)
        return ;
    if(cur_step==obj){
        if(Judge()){
            flag=1;
            sum=cur_step;
        }
        else {
            return ;
        }
    }

    for(int i=x;i<4;i++){
        for(int j=y;j<4;j++){
            if(i==x&&j==y){
                continue;
            }
            if(i<0||i>3||j<0||j>3){
                continue;
            }
            flip(i,j);

            Dfs(i,j,obj,cur_step+1);

            flip(i,j);
        }
    }
    return ;
}
int main(){
    memset(mmap,0,sizeof(mmap));
    char check;
    for(int i=0;i<4;i++){
        for(int j=0;j<4;j++){
            cin>>check;
            if(check=='b'){
                mmap[i][j]=1;//b 1,w 0
            }
        }
    }
    int step=0;//当前翻转棋子个数
    for(int l=0;l<=16;l++){//应该翻转的棋子个数
        Dfs(0,-1,l,step);
        if(flag==1){
            cout<<sum<<endl;
            break;
        }
        if(l==16){
            cout<<"Impossible";
        }
    }
    return 0;
}


 

 

 

POJ 1753
Joaniee的博客
08-08 936
1753 题是一个基本的枚举算法的题，基本解题思路就是暴力枚举，但是我们需要知道即便是暴力枚举，也是需要认真分析问题的。 题意：有一个4*4的棋盘,棋盘上有黑白格,每一次你可以翻其中的一个格子。一个格子(x,y)如果被翻,它相邻的前后左右四个格子（如果在棋盘上）也要翻转。现在给你一个初始的棋盘状态，问把这个棋盘翻转到全黑或全白的最少次数；若不能达到全黑或全白，输出Impossible。 思路：只有4*4的棋盘，同时格子只有黑白两面。对于同一个格子，翻两次和不翻没有区别。同时，我们会发现，假如第一行的状态已经
poj1753
Rebaccaminmin的博客
02-15 558
开始刷poj，从初级开始，枚举题1753，题目简短的来说就是一个棋盘，4x4的，有黑白棋两种，可以将一个棋翻过来，由黑面到白面，同时其周围的旗子也发生翻转。问输入一个棋盘，最少需要翻多少回棋子（每次翻一个，但其上下左右的棋子跟着会变化）使得整个棋盘全部白色或者全部黑色。 菜鸟一个并没有什么好的想法，想了一会后开始看别的大神们的思路（特别感谢優YoU http://user.qzone.qq.com
状态压缩动态规划 -- 棋盘问题 POJ 1321
一刀不二
06-21 1624
DFS太慢，用SCR好点点 Python 只有 22 行，其实可以更短，但是得排成很长很长的一行 while True: table = [ [ 0 for j in range( 300 ) ] for i in range( 12 ) ] table[0][0] = 1 boardsize, chessnum = map( int, raw_input().spli
Poj 1753
fuckohmylove的专栏
11-10 710
Flip Game Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 36059   Accepted: 15728 Description Flip game is played on a rectangular 4x4 field with two-sided pie
POJ 1753 Flip Game 题解
ComeTender的博客
02-07 588
POJ 1753 Flip Game 题解 题目解读 读到这个题目，首先要明确题目要求完成的任务。这道题的背景是翻转棋游戏。翻转棋游戏以4*4的棋盘为背景，有黑白两种颜色的棋子。现在题目中给出了在某一时刻棋盘上棋子的分布，要求每一回合选择棋盘上的某一个坐标，通过翻转规则作用棋盘发生变化。问最少经过几个回合能使得棋盘上的棋子变成全白或者全黑的状态。 显然，题目的重点在翻转规则：该游戏中，将
【POJ1198 Solitaire 】 思路+解题报告+测试数据生成器
c0de4fun的完美算(nei)法(he)教室-我们仍不知道，那天调用的驱动的名字。
03-16 1803
#include #include #include #include //#define DBG //#define INPUT //#define DBG1 using namespace std; /** Problem: poj1198 - Solitaire Begin Time : 18:33 15th/Mar/2012 End
POJ1321-Chess Problem
07-31
7. **状态压缩**：对于大棋盘，可以用位运算进行状态压缩，以节省空间。 由于没有具体的题目描述，以上只是根据一般编程竞赛经验的推测。实际的解题方法需要参考"POJ1321-Chess Problem.doc"提供的详细信息。在解决...
搜索专题突破POJ1077 POJ1324 POJ2046 HDU2485 HDU1560 HDU1667 POJ3134 POJ1915 HDU1401 HDU1430 HDU2691
Luowaterbi的博客
08-18 461
POJ1077Eight 八数码问题，就是手机上那个智能拼图的小游戏感觉很小的时候在诺基亚上玩过。只有一个块可以上下左右移动，问能否拼好。 IDA*搜索。估值函数就是目前拼图的曼哈顿距离。这是最理想化的情况，就是只经过曼哈顿距离，所有拼图回到自己位置。因为每次只能改变一个拼图的位置。所以最少就是曼哈顿距离。 估值函数的选取，就是去想最最理想的情况需要多少步达到目标。一般最理想都是实现不了，需...
POJ 搜索题
03-21 3039
一些好题目 POJ 1190 – 生日蛋糕(基础，好题) http://acm.pku.edu.cn/JudgeOnline/problem?id=1190 题意：略 解法：dfs，题偏简单，但做出来还是有些感觉的 POJ 1376 – Robot(基础) http://acm.pku.edu.cn/JudgeOnline/problem?id=1376 题意：略 解法：bfs
poj-1753
weixin_44500487的博客
03-28 470
Flip Game 题目大意：有一个4x4的棋盘，上面有黑白棋子，每次翻转一枚棋子，翻转的时候，其上下左右若有棋子，则也跟着翻转，要求判断最少需要几次才能够将棋盘翻转成纯色棋盘，即全为黑色或者全部为白色棋子，如果不可能就输出“Impossible”。 题解：每个棋子只能翻转1次，如果翻转2次的话就相当于没有翻转，所以整个棋盘最多翻转16次就可以求出整个棋盘的状态，所以只要求出1-16的全排序（总共...
棋盘问题---【状态压缩】
在人间贩卖声音
08-19 359
版权 此文章属于原创，看此文章前请先参考论文 周伟《动态规划之状态压缩》 问题1： 在n*n(n≤20)的方格棋盘上放置n个车(可以攻击所在行、列)，求使它们不能互相攻击的方案总数。 如果用组合学的角度来考虑此问题，那么非常简单： 我们一行一行放置，第一行有n种选择，第二行n-1，……，最后一行有1种选择，根据乘法原理，答案就是n! 这里我们介绍另一种解法：状态压缩递推(States Compressing Recursion,SCR)。 我们仍然一行一行放置。 取棋子的放置情况作为状态，某一列如果已
POJ 1753 Flip Game（枚举+状态压缩BFS）
weixin_30699463的博客
03-30 191
原题地址 http://poj.org/problem?id=1753 题意：十六宫格的棋盘，每个棋子有黑白两面，已知翻转某个棋子会造成其四周（若存在）的棋子都翻转。给定一个棋面，计算最少需要多少次能使整个棋盘的棋子全黑或全白。 解题思路 声明：本题的算法不是我自己的思路，学习了大神的方法，觉得是一种非常好的处理简单状态变迁的枚举问题，在这里做下笔记今后可以...
POJ 1753 BFS+状压
04-27 615
给出4*4的黑白棋盘 可以对任意一个点进行翻转（黑->白，或 白->黑），同时会翻转其相邻的四个点 问最少的步骤使棋盘变成全黑或者全白，状压存状态即可 #include "stdio.h" #include "string.h" #include "queue" using namespace std; int dir[5][2]={ {1,0},{-1,0},{0,1},{0,-
poj1321 棋盘问题（状态压缩）
LH
01-17 830
poj1321 棋盘问题（状态压缩） 棋盘问题Time Limit: 1000MS Memory Limit: 10000KTotal Submissions: 23884 Accepted: 11829Description在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。Input输
【状态压缩枚举】poj 1753 Flip Game
学无纸巾
11-22 379
poj 1753 Flip Game(状态压缩枚举) 题意：有一个4*4的棋盘，有白黑两种颜色的棋子，翻一次棋子，其颜色会改变并且其相邻的棋子颜色也会改变，问最少翻几次使得棋盘所有棋子颜色一样。 题解：状态压缩，将一种状态转变成一个数来表示，然后进行每个点的暴力dfs。#include <stdio.h> #include <string.h> #include <algorithm> #inc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值