状压DP学习总结 （详解，适合没状压dp基础的人学习，还在更新中，，，，）

本次博客，主要是给学弟学妹们讲解一下状压dp，不适合有基础的同学观看，可能会浪费时间，因为偏基础

先来最简单的一个吧   http://acm.hdu.edu.cn/showproblem.php?pid=1565 hdu 1565

方格取数(1)

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 11722    Accepted Submission(s): 4391

Problem Description

给你一个n*n的格子的棋盘，每个格子里面有一个非负数。
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取的数所在的2个格子不能相邻，并且取出的数的和最大。

Input

包括多个测试实例，每个测试实例包括一个整数n 和n*n个非负数(n<=20)

Output

对于每个测试实例，输出可能取得的最大的和

Sample Input

3 75 15 21 75 15 28 34 70 5

Sample Output

188

首先我们如果不考虑不能取连续的两个数，那么就像是一个数塔一样最简单的dp模型了，相邻的两个数不能取，我们要先理解最基本的状态，在类似状压bfs的时候也可以类比出来，再推一道很基本的状压bfs：http://acm.hdu.edu.cn/showproblem.php?pid=1429

那么我们可以对每一列，设为二进制状态，因为n比较少，最多也就(1 << 17) 

如果第i行状态为11001，那么说明我们第i行取得是1,4,5位置，那么对于第i行我们可以取这个状态，只与第i - 1行取得什么状态有关，如果第i - 1行的状态为y，要取第i行为x，那么一定要(x & y) == 0才满足不取相邻的两个（具体就是二进制位上不能有相同的1，利用&的特性，很容易理解），方程也很容易可以得到f[i][j]代表第i行取j这个状态，然后可以枚举第i - 1行的状态，在枚举第i行的状态，并且不冲突即可。当然我们暴力枚举时间复杂度是多少呢？显然是n*(1 << n)*(1 << n) ，复杂度肯定会挂，然而我们还需要考虑，因为我们每一行对于这个状态，都不能有相邻的两个1，对吧？

所以需要我们需要保存一些合法的状态，这个可以打表看一下最多有多少个（其实这个n根本就没有20，不然平方级别17000 * 17000 * 20还可以过5s么，亲测了一下，n只有16）

所以就是 2584 * 2584 * 16，所以复杂度现在就解决了，至于去除不合法的状态，就很简单了，(i & (i >> 1) )== 0则证明是合法状态，因为i往后搓一位后，如果还没有和i有重叠的1，那肯定都是合法的。

代码：

int a[19][1 << 17];
int f[19][1<<17];
int tot[maxn];
int calc(int i,int x){
    int cnt = 1,res = 0;
    while(x){
        if(x & 1)  res += a[i][cnt];
        x /= 2;cnt++;
    }
    return res;
}
int main()
{
    ios::sync_with_stdio(false);
    int n;
    while(cin >> n){
//        if(n >= 17){   while(1){   } }
        int cnt = 0,ans = 0;
        for(int i = 0;i < (1 << n);i++)   if((i & (i >> 1)) == 0) tot[++cnt] = i;
        for(int i = 1;i <= n;i++) for(int j = 1;j <= n;j++) cin >> a[i][j];
        MS0(f);
        for(int i = 1;i <= n;i++){
            for(int k = 1;k <= cnt;k++){
                int val = calc(i,tot[k]);
                for(int j = 1;j <= cnt;j++){
                    if((tot[j] & tot[k]) == 0){
                        f[i][k] = max(f[i][k],f[i - 1][j] + val);
                    }
                }
            }
        }
        for(int j = 1;j <= cnt;j++)  ans = max(ans,f[n][j]);
        cout << ans << endl;
    }
    return 0;
}

 

另外学习了上面的题，再来一个类似的， poj 1185 http://poj.org/problem?id=1185

炮兵阵地

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 34387		Accepted: 13208

Description

司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示： 

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。 
现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。 

Input

第一行包含两个由空格分割开的正整数，分别表示N和M； 
接下来的N行，每一行含有连续的M个字符('P'或者'H')，中间没有空格。按顺序表示地图中每一行的数据。N <= 100；M <= 10。

Output

仅一行，包含一个整数K，表示最多能摆放的炮兵部队的数量。

Sample Input

5 4
PHPP
PPHH
PPPP
PHPP
PHHP

我们再看这个题，只有P位置才可以放炮台，并且其他位置距离2的位置都会被占领，和刚刚的题很类似，刚刚的第i行只和i - 1有关，这个则与i - 1和i - 2有关，显然就多了以一维dp，那还是首先把所有合法的状态找出来，和刚刚的一样操作，定义f[i][j][k]状态为：第i行状态为j，第i - 1行状态为k的能放炮兵的个数。现在就又可以枚举第i行的第j个状态，另外再接着枚举第i - 1行的状态和第i - 2行的状态，首先先要check（j）这个状态是不是合法的，这个合法代表的是选取的每一位是否和第i行的位置对应并且他们都有p，或者这个状态是所有p的子集，一种方法，暴力挨个位数判断，那我们对于每个状态都要判断，第i、i - 1、i - 2，所以就会再复杂度上再加上一个级别

现在我们考虑怎么优化，我们可以把第i行的状态预处理出来，即有P的地方都变为1，处理出op[i]，代表第i行的全集，那么op[i] & j 如果>0则可以表示与第i行的P的位置有冲突 其他的i - 1和i - 2一样的道理

那么我们可以列出方程

j 为 第i行的状态，k为第i - 1行的状态，p为i - 2行的状态，num则是j状态1的个数，就是选了多少个P，对于这个num，我们可以用暴力算出二进制1的个数从而得来，但是我们对这里也可以进行一个优化

f[i][j][k] = max(f[i][j][k],f[i - 1][k][p] + num)

现在问题就来到了能不能O1时间内得到x的二进制1的个数，那么我们可以根据树状数组的lowbit(x)在O1时间内得到x的末尾0的个数（当然这个（x&(-x)）是真的太神奇了），现在我们可以枚举状态到(1 << m)，假设

101100这个1的个数显然可以从101的1的个数+1得来，所以我们可以到i - lowbit(i)得到101的1的个数，并且101的个数是以及枚举过得

代码：

char str[190][1 << 10];
int f[190][80][80];
int tot[maxn];
//int f[i][j][k];///第i行,第i行取的状态是j,第i - 1行取得状态是k
int op[maxn];
int num[maxn];
int main()
{
//    ios::sync_with_stdio(false);
    int n,m;
    cout << lowbit(3) << endl;
    while(cin >> n >> m){
        int cnt = 0;
        for(int i = 1;i <= n;i++)  scanf("%s",str[i]);
        for(int i = 0;i < (1 << m);i++)     if(((i & (i >> 2)) == 0) && (i & (i >> 1)) == 0) tot[++cnt] = i;
        for(int i = 1;i < (1 << m);i++) {
        num[i] = num[i - lowbit(i)] + 1;
        cout << lowbit(i) << "  ";
        cout << i <<"   " << i - lowbit(i) <<  "    " << num[i] <<endl;
        }
        int ans = 0;
        for(int i = 1;i <= n;i++){
            for(int j = 0;j < m;j++) op[i] |= ((str[i][j] == 'H') << j);
            for(int j = 1;j <= cnt;j++){ ///枚举第i层的状态
                if((tot[j] & op[i])) continue;
                for(int k = 1;k <= cnt;k++){///枚举第i - 1的状态
                    if(tot[j] & tot[k]) continue;int val = num[tot[j]];
                    if(i >= 2 && (tot[k] & op[i - 1]))continue;
                    for(int p = 1;p <= cnt;p++){///枚举第i - 2的状态
                        if(tot[p] & op[i - 2]) continue;
                        if((tot[p] & tot[k]) == 0 && (tot[j] & tot[p]) == 0)   f[i][j][k] = max(f[i][j][k],f[i - 1][k][p] + val);
                    }
                    ans = max(f[i][j][k],ans);
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}

最后再来一个例子吧  uva11825

 https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2925

Miracle Corporations has a number of system services running in a distributed computer system which
is a prime target for hackers. The system is basically a set of N computer nodes with each of them
running a set of N services. Note that, the set of services running on every node is same everywhere
in the network. A hacker can destroy a service by running a specialized exploit for that service in all
the nodes.
One day, a smart hacker collects necessary exploits for all these N services and launches an attack
on the system. He finds a security hole that gives him just enough time to run a single exploit in each
computer. These exploits have the characteristic that, its successfully infects the computer where it
was originally run and all the neighbor computers of that node.
Given a network description, find the maximum number of services that the hacker can damage.
Input
There will be multiple test cases in the input file. A test case begins with an integer N (1 ≤ N ≤ 16),
the number of nodes in the network. The nodes are denoted by 0 to N − 1. Each of the following
N lines describes the neighbors of a node. Line i (0 ≤ i < N) represents the description of node i.
The description for node i starts with an integer m (Number of neighbors for node i), followed by m
integers in the range of 0 to N − 1, each denoting a neighboring node of node i.
The end of input will be denoted by a case with N = 0. This case should not be processed.
Output
For each test case, print a line in the format, ‘Case X: Y ’, where X is the case number & Y is the
maximum possible number of services that can be damaged.
Sample Input
3
2 1 2
2 0 2
2 0 1
4
1 1
1 0
1 3
1 2
0
Sample Output
Case 1: 3
Case 2: 2

仔细读题，题意描述有点怪，其实就是给你第i个点和与他相邻的点，让你求出他可以最多有多少个没有任何交集的集合，使得任意集合的所有点再加上相邻的点，从而覆盖全部的图，问你最多可以有多少个这样的集合

对于下面这个图，那他就可以找出3个集合，分别是

{4,0}、{3,5}、{1,2}

对这种，我们显然是肯定可以枚举他的子集的，并且再去找与他不相交的集合里，能不能构成覆盖所有点的条件

我们就可以针对n来枚举子集，看下面这个dfs函数，n代表我取得状态，然后我们再去枚举n的子集，那么枚举n的子集需要多少复杂度呢，最明显的可以用枚举所有状态&n，判断他是不是n的子集，并且再考虑计算，这样的话，复杂度就是2^n，我们最外层枚举n的所有状态又是2^n，这样就得到了4^n，n = 16，所以是不可行的，虽然有的地方我们可以加一个记忆化，但是复杂度还是通过不了的（dfs的复杂度可能不好计算，下面还有一个递推方式的写法）
int dfs(int n){
    if(f[n] != -1) return f[n];
    int ans = 0;
    for(int i = n;i;i = ((i - 1) & n))   if(check(j)) ans = max(ans,dfs(i ^ n) + 1);
    return f[n] = ans;
}

             for(int i = 0; i < (1 << n);i++){
                int ans = 0;
                for(int j = i;j;j = (j - 1) & i){
                 if(check(j)){
                        ans = max(ans,f[i ^ j] + 1);
                    }
                }
                f[i] = ans;
             }

现在我们来考虑怎么优化，怎么快速的找到i的子集呢，假如我们枚举所有的状态， 那么就会出现很多浪费枚举的时候，所以我们可以用一个特别巧妙地方法我们知道 i & n == i 是用来判断i是否是n的子集的（具体是为什么，写一下就知道了），那我们如果想枚举完i的子集，我们可以还是通过i--，来找到i的下一个最近的状态，但是这个i不一定是n的子集，所以我们可以用上面判断的方法来得到最近的符合是n的子集的状态，那就是(i - 1) & n，实在理解不了，就记下来吧。那这样可以优化多少时间复杂度呢

我们来看递推的dp复杂度，观察第一层for是2^n的复杂度，第2层for是只跟集合的大小有关系的，那么就是有

C(n,1) + C(n,2) + .... =  ，这样的话，我们考虑大小为i的集合，就有2^i个子集， 那我们现在一起来考虑整个两层for循环的复杂度，就是∑C(n,i) * 2 ^ i，有没有发现这个东西很熟悉，那就是二项式定理了

所以 ∑C(n,i) * 2 ^ i = 3 ^ i，大小为n的集合就是 3 ^ n，所以现在复杂度就有了

那我们的check要怎么写的呢，要在O1时间内，check出当前选的状态，可以覆盖完所有的图

首先我们可以对他输入的边进行处理，因为他出的是第i个点和哪些点有边，所以我们可以先预处理出一个p数组，表示选择i点可以与那些点相连，就是p[i] |= (1 << x)，然后我们再来枚举0到(2^n)- 1的所有状态，定义一个arr数组，arr[i]，i这个状态可以达到的点都有谁，对于每个状态，我们看看选了哪些点j，arr[i] |= p[j] ，就可以得到当前i状态可以达到的所有点的状态，那判断的时候，arr[i] == (1 << n) - 1 就可以表示所有的图的点都可以被覆盖了

代码：

int f[maxn];int k;
int p[maxn],arr[maxn];
int dfs(int n){
    if(f[n] != -1) return f[n];
    int ans = 0;
    for(int i = n;i;i = ((i - 1) & n))   if(arr[i] == ((1 << (k)) - 1)) ans = max(ans,dfs(i ^ n) + 1);
    return f[n] = ans;
}
int main()
{
    int n;
    int cas = 1;
    while(cin >> n){
        k = n;
        if(n == 0) break;
        MS1(f); MS0(p);MS0(arr);
        int m,x;
        for(int i = 0;i < n;i++){
            cin >> m;
            p[i] = (1 << i);
            for(int j = 1;j <= m;j++){
                cin >> x;
                p[i] |= (1 << x);
            }
        }
         for(int i = 0; i < (1 << n);i++){ ///2 ^ n
                for(int j = 0;j < n;j++){
                    if(i & (1 << j)) arr[i] |= p[j];
                }
         }
         /**
             for(int i = 0; i < (1 << n);i++){
                int ans = 0;
                for(int j = i;j;j = (j - 1) & i){
                    if(arr[j] == (1 << n) - 1){
                        ans = max(ans,f[i ^ j] + 1);
                    }
                }
                f[i] = ans;
             }
         */
         dfs((1 << n)- 1);
         printf("Case %d: %d\n",cas++,f[(1 << n) - 1] );
    }
    return 0;
}