[hdu2167]Pebbles（状态压缩dp）

[hdu2167]Pebbles

(http://acm.split.hdu.edu.cn/showproblem.php?pid=2167)

Description

题意大概的意思就是有一个n*n(n<=15)的矩阵，在其中选一个数，选了一个数之后与他相邻（八个方向）的全部都不能选，可以选若干个数，求这些数加起来最大的和。

Input

输入若干个矩阵，其他n什么的都不输入

Output

题意所求的最大和

Sample Input

71 24 95 56 54
85 50 74 94 28
92 96 23 71 10
23 61 31 30 46
64 33 32 95 89

78 78 11 55 20 11
98 54 81 43 39 97
12 15 79 99 58 10
13 79 83 65 34 17
85 59 61 12 58 97
40 63 97 85 66 90

33 49 78 79 30 16 34 88 54 39 26
80 21 32 71 89 63 39 52 90 14 89
49 66 33 19 45 61 31 29 84 98 58
36 53 35 33 88 90 19 23 76 23 76
77 27 25 42 70 36 35 91 17 79 43
33 85 33 59 47 46 63 75 98 96 55
75 88 10 57 85 71 34 10 59 84 45
29 34 43 46 75 28 47 63 48 16 19
62 57 91 85 89 70 80 30 19 38 14
61 35 36 20 38 18 89 64 63 88 83
45 46 89 53 83 59 48 45 87 98 21

15 95 24 35 79 35 55 66 91 95 86 87
94 15 84 42 88 83 64 50 22 99 13 32
85 12 43 39 41 23 35 97 54 98 18 85
84 61 77 96 49 38 75 95 16 71 22 14
18 72 97 94 43 18 59 78 33 80 68 59
26 94 78 87 78 92 59 83 26 88 91 91
34 84 53 98 83 49 60 11 55 17 51 75
29 80 14 79 15 18 94 39 69 24 93 41
66 64 88 82 21 56 16 41 57 74 51 79
49 15 59 21 37 27 78 41 38 82 19 62
54 91 47 29 38 67 52 92 81 99 11 27
31 62 32 97 42 93 43 79 88 44 54 48

Sample Output

572
683
2096
2755

这题是最典型的状压dp，需要运用二进制去解决，我们把每一行的状态看成一个二进制数，选了数的那一格是1，没选的是0，由于(n<=15)，所以每一行只有(1<<15)种状态，也就是65535种状态，然而这么多状态中有大多数的是废状态（有相邻的1的状态），这些状态都是没用的，所以我们新开一个数组来储存有用的状态（其实在这么65535种状态中只有不到2000的状态是有用的）就可以完成此题

c++code：

#include
#include
#include
#include
#include
using namespace std;
int f[16][1<<15];//f[i][j]代表第i行低j个状态的最优解
int a[16][16],v[1<<15],vn,bit[20];
//v储存有用的状态,vn是有用的状态的数量，bit储存二的幂
char s[110000];
int n;
int main()
{
    bit[1]=1;for(int i=2;i<=15;i++) bit[i]=(bit[i-1]<<1);
    int i,j;
    while(scanf("%d",&a[1][1])!=EOF)
    { 
        char c;scanf("%c",&c);
        n=1;
        while(c!='\n')
        {
            n++;
            scanf("%d",&a[1][n]);
            scanf("%c",&c);
        }
        for(int i=2;i<=n;i++)for(int j=1;j<=n;j++)scanf("%d",&a[i][j]);
        memset(f,0,sizeof(f));
        vn=0;
        int maxx=(1<1;//状态的最多maxx个
        for(int x=0;x<=maxx;x++) 
        {
            if(((x<<1)&x)==0)
            {
                for(int j=1;j<=n;j++)
                {
                    if(bit[j]&x)
                    {
                        f[1][x]+=a[1][j];
                    }
                }
                v[++vn]=x;
            }
        }
        for(int i=2;i<=n;i++)
        {
            for(int p=1;p<=vn;p++)
            {
                int tt=0;for(int j=1;j<=n;j++)if(bit[j]&v[p])tt+=a[i][j];
                for(int q=1;q<=vn;q++)
                {
                    if( ( v[p]&v[q] )==0  && ( ( v[q]<<1 ) & v[p] )==0 && ( ( v[q]>>1 ) & v[p] )==0)
                    {
                        f[i][v[p]]=max(f[i][v[p]],f[i-1][v[q]]+tt);
                    }
                }
            }
        }
        int ans=0;for(int p=1;p<=vn;p++)ans=max(ans,f[n][v[p]]);
        printf("%d\n",ans);
    }
    return 0;
}