HDU2209翻纸牌游戏(位运算+搜索）

Problem Description

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

 

Input

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

 

Output

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

 

Sample Input

  
  

   
   01
011
  
  

 

Sample Output

  
  

   
   NO
1
  
  

很懵逼，题目意思有毒，只会影响附近的一张导致我以为只会影响左边或者右边两者中的一张。。。。。

分析:从最终结果出发不管最终纸牌翻转成什么样,第一张纸牌只有两种情况:1.翻转过,2:未翻转过

而影响第一张纸牌的只有本身和第二张纸牌,

所以分两种情况:1：第一张纸牌本身翻转,然后搜索第2,3,4,....n张并由第i-1张纸牌是否正面朝上而决定第i张是否翻转(第i-1张纸牌前的纸牌已全部正面朝上),最后只需要判断第n张纸牌是否正面朝上即可

2:第一张纸牌本身不翻转,然后过程和第1种情况一样

DFS

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int INF = 0x3f3f3f3f;
int num[30];
int dfs(int pos, int len, int tol)
{
    if(pos == len)
        return num[pos-1] ? INF : tol;
    if(num[pos-1])
        num[pos-1] = 0, num[pos] = !num[pos], num[pos+1] = !num[pos+1], tol++;
    return dfs(pos+1, len, tol);
}
int main()
{
    char a[30];
    while(scanf("%s", a) != EOF)
    {
        int len = strlen(a), sum = INF;
        for(int i = 0; i < len; i++)
            num[i] = a[i] - '0';
        sum = min(sum, dfs(1, len, 0));
        for(int i = 0; i < len; i++)
            num[i] = a[i] - '0';
        num[0] = !num[0];num[1] = !num[1];
        sum = min(sum, dfs(1, len, 1));
        if(sum == INF)
            cout << "NO\n";
        else
            cout << sum << endl;
    }
    return 0;
}

BFS+位运算

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
const int maxn = (1<<20) + 10;
bool vis[maxn];
struct Node
{
    int num, step;
    Node(){}
    Node(int _num, int _step) : num(_num), step(_step){}
};
int main()
{
    char p[25];
    while(scanf("%s", p) != EOF)
    {
        int now = 0;
        memset(vis, false, sizeof(vis));
        int len = 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
         注：位运算不改变原值
         */
        vis[now] = 1;
        queue<Node> q;
        Node tem(now, 0);
        q.push(tem);
        while(!q.empty())
        {
            tem = q.front();
            if(!tem.num)
                break;
            q.pop();
            for(int i = 0; i < len; i++)
            {
                now = tem.num^1<<i;
                /*
                 xor操作。
                 前数转化成二进制后的每一位与后数的对应位进行比较，相同则该位为0，不同则该位为1。
                 换句话说，每一位数对应的位若是1则该位取反，若对应的位为0则不变
                 此为位运算，同样不会改变原数的值
                 */
                if(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])
                {
                    q.push(Node(now, tem.step+1));
                    vis[now] = true;
                }
            }
        }
        if(q.empty())
            printf("NO\n");
        else
            printf("%d\n", q.front().step);
    }
    return 0;
}