神奇的位操作

&, |, ^.<<, >>

1.快速判重。　　数组A， B分别由 010111,  111001, 取& 为 010001， 即为相同。（如果用数组，所用空间为此方法的n倍， 具体使用利弊看具体问题）

2.快速取状态　　数组A， B分别由 010111,  111001, A的第3个数是否为一：A & (1 << (3-1)) .

3.状态快速相加。数组A， B分别由 010111,  111001， 和状态为　　A | B = 　　111111。

适用: 数组暴力，枚举的只是状态（1 or 0）。

例: uva 690 流水线，

　　每个unit不能同一时刻处理两个程序。状态：有程序和没程序。暴力dfs加剪枝。 暴力枚举每个程序的起始时间，然而中间处理过程太过繁琐，且优化不算明显故超时。 看题解得：枚举当前所需要考虑的长度编号与上一个的起始时间的相差时间（提前处理不能枚举的数据），另取数组保留当前状态（而不是储存起始时间）。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <map>
#include <set>
#define LL long long
#include <vector>
#define mst(a, b) memset(a, b, sizeof(a))
//freopen(in.txt, "r", stdin);
//freopen(out.txt, "w", stdout);
using namespace std;
int n, unit[6], jump[25], num_jump, ans;
bool Judge(int *A, int x)
{
    for(int i = 0; i < 5; i++)
    {
        if((A[i] >> x) & unit[i]) return false; //one unit has only one program
    }
    return true;
}
void init()
{
    char str[25];
    for(int i = 0; i < 5; i++)
    {
        scanf("%s", str);
        for(int j = 0; j < n; j++)
        {
            if(str[j] == 'X') unit[i] |= (1 << j);
        }
    }
    num_jump  =0;
    for(int i = 0; i <= n; i++)
    {
        if(Judge(unit, i))
            jump[num_jump++] = i;
    }

}

bool dfs(int *A, int cur, int sum)
{
    if(sum + jump[0] * (10 - cur) > ans) return false;
    if(cur == 10)
    {
        ans = min(ans, sum);
        return true;
    }
    for(int i = 0; i < num_jump; i++)
    {
        if(Judge(A, jump[i]))
        {
            int B[6];
            for(int j = 0; j < 5; j++)
            {
                B[j] = (A[j] >> jump[i]) ^ unit[j];
            }
            dfs(B, cur+1, sum + jump[i]);
        }
    }
    return false;
}
int main()
{
    while(scanf("%d", &n) != EOF && n)
    {
        mst(unit, 0);
        mst(jump, 0);
        init();
//        int A[6] = {0};
//        memcpy(A, unit, sizeof(unit));
        ans = n * 10;
        dfs(unit, 1, n);
        printf("%d
", ans);
    }
    return 0;
}

：数据小可暴力枚举，状态储存。

神奇操作：

1. 获得该数上的1的个数： int nums(int m) { return m == 0 ? 0 : nums(m / 2) + (m & 1); }

2. 获得1的最低位　　　　　　int lowbit(int x) { return x & -x; }