【基本算法】 位运算：二进制状态压缩

二进制状态压缩

二进制状态压缩，是指将一个n位的 bool 数组用 n 位的二进制数表示的方法。

OP	运算
取出 n 在二进制表示下的第k位	(n >> k) & 1
取出 n 在二进制表示下的0~ k-1 位（后k位）	n & ((1<<k) - 1)
把整数n在二进制表现下的第k位取反	n xor (1 << k)
把整数n在二进制表现下的第k位赋值1	n | (1 << k)
把整数n在二进制表现下的第k位赋值0	n & (~(1 << k))

注：Markdown表格中的 " | " 使用 | 来表示；

我们以13 （1101）为例，看一下位运算的实现过程

1. 取出第k位： (n >> k) & 1

k	3	2	1	0
n	1	1	0	1

需要注意的是：k的取值是从0开始的，并且位数是按照从右到左的顺序计算；

2. 取出后k位：n & ((1 << k) - 1)

k	4	3	2	1
n	1	1	0	1

为什么这次k对应的是从1开始的呢？
我们来对照一下 (1 << k) / (1 << k) - 1 的结果

k	4	3	2	1
(1 << k)	10000	1000	100	10
(1 << k) - 1	1111	111	11	1
n & ((1 << k) - 1)	1101	101	01	1
n	13	5	1	1

3. 第k位取反 n xor (1 << k)

k	3	2	1	0
n xor (1 << k)	0101	1001	1111	1100

这个的原理其实很简单，1 << k 位后，那么 (k+1) 位为1，其他都是0.
n xor (1 << k) 只会有4种情况

运算	结果
0 xor 1	1
1 xor 1	0
1 xor 0	1
0 xor 0	0

无论0还是1，异或1都是取反，异或0不变

４. 第k位赋值1
原理同上， 无论什么数 “|1” 都是 1，所以将1 << k 位后，与n或运算，都可以使其为1；

k	3	2	1	0
n | (1 << k)	1101	1101	1111	1101

5. 第k位赋值0
~(1 << k) 这个操作可以使 第k位 = 0， 从0 ~ (k-1)位都为1.
任何数 & 1 都保持不变，第k位 & 0 赋值为 0；

k	3	2	1	0
n & (~(1 << k))	0101	1001	1101	1100

例题：最短 Hamilton 路径

题目描述

给定一张 n(n≤20) 个点的带权无向图，点从 0~n-1 标号，求起点 0 到终点 n-1 的最短Hamilton路径。 Hamilton路径的定义是从 0 到 n-1 不重不漏地经过每个点恰好一次。
In

第一行一个整数n。
接下来n行每行n个整数，其中第i行第j个整数表示点i到j的距离（一个不超过10^7的正整数，记为a[i,j]）。
对于任意的x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x] 并且 a[x,y]+a[y,z]>=a[x,z]。
Out

一个整数，表示最短Hamilton路径的长度。

Input

4
0 2 1 3
2 0 2 1
1 2 0 1
3 1 1 0
Output

4

Hint

从0到3的Hamilton路径有两条，0-1-2-3和0-2-1-3。前者的长度为2+2+1=5，后者的长度为1+2+1=4

---

这是一道经典的状压DP题，作为一个NP完全问题，我们只关心两个问题

1. 哪些点被用过
2. 目前停在哪里

我们使用一个n位的二进制数，若其第 i 位为 1 ，则表示第 i 个点已经被经过
使用 F[ i , j ] 来表示，当前经过状态state ， 和目前在第 j 个点上
起点 F[ 1 , 0 ] = 0 最终目标 F[ (1<<n)-1 , n-1] 所有点都被访问到，且当前处于 n-1；
状态转移方程 F[ i , j ] = min { F [ i xor (1 << j ) , k) ] + weight( k , j ) }

AC代码

#include <bits/stdc++.h>
using namespace std;

const int N = 20 , M = 1<<20;
int n;
int f[M][N], weight[N][N];

int main()
{
    cin >> n;
    for(int i = 0;i < n; i++)
        for(int j = 0;j < n; j++)
            cin >> weight[i][j];
            
    memset(f,0x3f,sizeof f);
    f[1][0] = 0;                  //第一个点不需要费用
    
    for(int i = 0;i < 1<<n; i++)  //状态
        for(int j = 0;j < n; j++) // 走到第j个点
            if( i >> j & 1)       //到达过第j个点
                for(int k = 0; k < n;k++)                                  //枚举能到达j的所有k个点
                    if( (i^1<<j)>>k & 1)                                  //如果没有走到j，并且当前是k
                        f[i][j] = min(f[i][j], f[i^1<<j][k]+weight[k][j]); //选择最小值，k点到j点最优，还是以前的方案最优
    
    cout << f[(1<<n)-1][n-1]<<endl; //最终到达
}

转载于:https://www.cnblogs.com/Coder-L/p/11006361.html