poj-1753 Flip Game

http://poj.org/problem?id=1753

一道枚举+搜索的经典题，dfs和bfs都行。也通过这题更加理解了状态压缩，和位运算。不过还是看了大神的题解。  http://www.cnblogs.com/timebug/archive/2010/04/01/1702518.html

 

#include<cstdio>
#include<cstring>
/*void init()//打表  枚举每一个点翻转后的变化情况，共有十六个点，
{         //最终是要把当前状态转化为十进制，比如样例表示为 1001110110011000
    int p[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
    int i,j,k,temp,x,y;
    for(i=0;i<4;i++)
    {
        for(j=0;j<4;j++)
        {
            temp=0; //异或操作就是相同为0，不同为1
            temp^=(1<<(i*4+j));//当前点  （在第i行需要乘以4，+j列表示需要右移的位数
            for(k=0;k<4;k++)
            {
                x=i+p[k][1];
                y=j+p[k][0];
                if(x<0||y<0||x>3||y>3) continue;
                temp^=(1<<(x*4+y));//四个方向  都异或一次
            }
            printf("%d ",temp); //最后返回的既是当前点翻转后代表的十进制数
        }
    }
}
*/
int t[]={19,39,78,140,305,626,1252,2248,4880,10016,20032,35968,12544,29184,58368,51200};
const int SIZE=65535;
int MIN;
/*void dfs(int state,int num,int deep)
{   dfs耗时，因为需要枚举到全部情况，不想bfs满足直接退出。
    if(deep>15)
    {
        if(state==0||state==65535)//如果满足状态
            if(num<MIN) MIN=num;//就更新最小值
    }
    return;
    dfs(state^t[deep],num+1,deep+1);//递归下一个状态，
    dfs(state,num,deep+1);//或者当前状态不变，deep++，既是保证能枚举到全部情况

}*/
int bfs(int state)
{
    int vis[SIZE],d[SIZE],u,v,i;
    int qu[SIZE],rear,front;//模拟队列，头指针，尾指针
    memset(vis,0,sizeof(vis));
    vis[state]=1; //标记数组
    d[state]=0; //存储步数
    rear=front=0;
    qu[++rear]=state; //用数组来模拟队列，把元素赋给尾指针
    while(rear!=front)
    {
        u=qu[++front]; //把队首元素赋给u
        for(i=0;i<16;i++)
        {
            v=u^t[i];//当前状态，异或t数组中一个元素，则当前状态会进行改变，就像翻转了一个位置
            if(v==0||v==65535) return d[u]+1;//如果达到了要求，就返回
            if(vis[v]==0)
            {
                vis[v]=1;  //标记为1
                d[v]=d[u]+1; //步数加1
                qu[++rear]=v; //扩展入队
            }
        }
        vis[u]=-1; //回溯
    }
    return -1;
}

int main()
{
    char ch[5][5];
    int i,j,start;
    while(scanf("%s",ch[0])!=EOF)
    {
        start=0;
        for(i=1;i<4;i++)
            scanf("%s",ch[i]);
        for(i=0;i<4;i++)
            for(j=0;j<4;j++)
            if(ch[i][j]=='b') start^=(1<<((3-i)*4+(3-j)));//跟打表过程一样，把初始状态转换为10进制数
        if(start==0||start==65535) printf("0\n");//初始状态符合要求，就输出
        else
        {
            int result=bfs(start);  //否则  bfs
            result==-1?printf("Impossible\n"):printf("%d\n",result);
            //dfs(start,0,0);
            //MIN==0xfffffff?printf("Impossible\n"):printf("%d\n",MIN);
        }
    }
    return 0;
}

 还可以用深搜写，比较简单，就是枚举每一个点是否符合，还要记得回溯。

#include<cstdio>
int s[5][5];//把字母转换为数字
int flag,step;
int range() //判断当前局面是不是全部一样
{
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
        if(s[i][j]!=s[0][0]) return 0;
    return 1;
}

int change(int x,int y) //改变当前坐标和相邻坐标
{
    s[x][y]=!s[x][y];
    if(x<3) s[x+1][y]=!s[x+1][y];
    if(x>0) s[x-1][y]=!s[x-1][y];
    if(y<3) s[x][y+1]=!s[x][y+1];
    if(y>0) s[x][y-1]=!s[x][y-1];
}

void dfs(int x,int y,int deep)
{
    if(deep==step)
    {
        flag=range();
        return;
    }
    if(flag||x==4) return;
    change(x,y); 
    if(y<3) dfs(x,y+1,deep+1); //首先一列列搜
    else dfs(x+1,0,deep+1); //转到下一行
    change(x,y);  //回溯
    if(y<3) dfs(x,y+1,deep); //从下一坐标开始
    else dfs(x+1,0,deep);
    return;
}

int main()
{
    char c;
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<4;j++)
        {
            scanf("%c",&c);
            if(c=='b') s[i][j]=0;
            else s[i][j]=1;
        }
        getchar();
    }
    for(step=0;step<=16;step++) //因为最多只有16步 所以一步步枚举
    {
        flag=0;
        dfs(0,0,0);
        if(flag) break;
    }
    if(flag) printf("%d\n",step);
    else printf("Impossible\n");
    return 0;
}