HDU 2209 翻纸牌游戏 解题报告

Description

有一种纸牌游戏，很有意思，给你N张纸牌，一字排开，纸牌有正反两面，开始的纸牌可能是一种乱的状态（有些朝正，有些朝反），现在你需要整理这些纸牌。但是麻烦的是，每当你翻一张纸牌（由正翻到反，或者有反翻到正）时，他左右两张纸牌（最左边和最右边的纸牌，只会影响附近一张）也必须跟着翻动，现在给你一个乱的状态，问你能否把他们整理好，使得每张纸牌都正面朝上，如果可以，最少需要多少次操作。

Input

有多个case，每个case输入一行01符号串（长度不超过20），1表示反面朝上，0表示正面朝上。

Output

对于每组case，如果可以翻，输出最少需要翻动的次数，否则输出NO。

Sample Input

01
011

Sample Output

NO
1

---

       一种解法是在网上看到解题思路，另一种是之后整理这道题的时候自己想的方法。

       先说自己想的。纸牌数最多只有二十，因此一副纸牌的摆放方法最多只有2^20种。将这些摆法视为0~2^20-1这些数。利用visit数组确定某种情况是否出现过，利用位运算的方法操作将某种情况转化为对应的数，数0即表示全部正面朝上这种情况。BFS暴力搜索。

#include <iostream>
#include <queue>
#include <cstring>
using namespace std;

char p[25];
int vis[1048580];
int now;
struct node
{
    int num,step;
}n;
int main()
{
    while(~scanf("%s",p))
    {
        now=0;
        int len=(int)strlen(p);
        for(int i=0;i<len;i++)
            now=now|(p[i]-'0')<<i;
        /*
         1.p[i]-'0',将字符‘0’与‘1’转化为数0与1
         2.(p[i]-'0')<<i，将数0或1，向左移动i位。
         例如，将数字1移动2位，即0001变为0100
         3.now|(p[i]-'0')<<i，将now与移动后的数进行or操作。
         由于移动后的数转化成二进制后，除某一位数外，其他皆为0。
         因此此操作即为，若该位为0则无影响，若该位为1则将now转换成二进制数后的对应位变更为1
         注：位运算不改变原值
         */
        memset(vis, 0, sizeof(vis));
        vis[now]=1;
        queue<node> q;
        n.num=now;
        n.step=0;
        q.push(n);
        while(!q.empty())
        {
            node f=q.front();
            if(!f.num)
                break;
            q.pop();
            for(int i=0;i<len;i++)
            {
                now=f.num^1<<i;
                /*
                 xor操作。
                 前数转化成二进制后的每一位与后数的对应位进行比较，相同则该位为0，不同则该位为1。
                 换句话说，每一位数对应的位若是1则该位取反，若对应的位为0则不变
                 此为位运算，同样不会改变原数的值
                 */
                if(len==1)
                    ;//这个。。。表示下面的else if 和else 默认len!=1
                else if(i==0)
                    now=now^1<<(i+1);
                else if(i==len-1)
                    now=now^1<<(i-1);
                else
                {
                    now=now^1<<(i+1);
                    now=now^1<<(i-1);
                }
                if(!vis[now])
                {
                    n.num=now;
                    n.step=f.step+1;
                    q.push(n);
                    vis[now]=1;
                }
            }
        }
        if(q.empty())
            printf("NO\n");
        else
            printf("%d\n",q.front().step);
    }
    
    return 0;
}

        在网上看到的解法，采取从左到右的顺序操作，不走回头路。

        我并没有全部理解。。。

        从左到右，除第一张牌外，每一张牌的改变都会改变其左侧相邻的牌（第一张牌左边没牌哈）。如果一张牌其左侧相邻的牌为反面，那么即可通过直接改变这张牌，来间接改变其左侧的牌。如果其左侧相邻的牌为正面，则不直接操作这张牌。因此依此法，易知这张牌之后，便无法通过操作改变这张牌左侧所有的牌。从左到右执行完后，最后一张牌前面的牌一定都为正面，所以最后一张牌为正面即得到解，最后一张牌为负面则未得到解（按照这一流程，似乎可以保证对第一张牌之后的牌的操作最优。我可理解若此法能使所有牌皆正面的情况下，则此法操作数最少；但我无法证明若此法不能使所有牌皆正面的情况，没有其他的操作方法可以达成目标）。

       因此，剩下的问题就在于第一张牌。容易有的错觉是，第一张牌为正时，开始执行以上从第二张牌开始的操作为最优。然而并不是这样。比如0101，初始时第一张牌即为正，但是直接从第二张牌开始执行上述操作的结果是0001，无法使得所有牌皆正面（0101->0010->0001）；然而若先把第一张牌改为反面（同时间接将第二张牌改为正面），即1001，而后在从第二张牌开始执行上述操作，则可得到解(0101->1001->0111->0000)。因此，分两种情况，分别为第一张牌为正面和第一张牌为负面，而后分别从第二张牌开始执行上述指令。取最少操作数的一种情况为最优解。注意，通过对第一张牌的直接操作，从而确定第一张牌的另一种初始情况的这一操作，也要计数（+1）。

//知其然不知其所以然

#include <iostream>
#include <queue>
#include <cstring>
#include <cstdio>
#define maxn 25
#define wrong 100000
using namespace std;


int pai[maxn];
char w[maxn];

int dfs(int i,int len,int sum)
{
    if(i==len)
        return pai[i-1]==0?sum:wrong;
    if(pai[i-1]==1)
    {
        pai[i-1]=0;
        pai[i]=!pai[i];
        pai[i+1]=!pai[i+1];
        sum++;
    }
    i++;
    return dfs(i,len,sum);
}

int main()
{
    while(scanf("%s",w)==1)
    {
        int len=(int )strlen(w);
        int min=wrong;
        for(int i=0;i<len;i++)
            pai[i]=w[i]-'0';
        pai[0]=!pai[0];
        pai[1]=!pai[1];
        int ans=dfs(1,len,1);
        min=min<ans?min:ans;
        for(int i=0;i<len;i++)
            pai[i]=w[i]-'0';
        ans=dfs(1,len,0);
        min=min<ans?min:ans;
        if(min==wrong)
            printf("NO\n");
        else
            printf("%d\n",min);
    }
    
    return 0;
}