hdu 1565 方格取数(1) 状态压缩dp

方格取数(1)

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

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

 

Author

ailyanlu

 超内存，用滚动数组了，超时！

算一下时间复杂度 20*20*2^20*2^20 额额。。。。

 

超时代码留个标记

 #include<iostream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 using namespace std;

 int a[][];
 int dp1[<<],before[<<],now[<<];

 void prepare(int i,int n)//预处理
 {
     int j,k,s;
     k=<<n;
     for(j=; j<k; j++)
     {
         dp1[j]=;
         for(s=; s<=n; s++)
         {
             if( (j&(<<(s-))) == (<<(s-)) )//包含了这个数字
                 dp1[j]=dp1[j]+a[i][s];
         }
     }
 }
 bool panduan(int b,int n)
 {
     int i,x;
     x=;
     for(i=; i<n; i++)
     {
         if( (x&b) == x) return false;
         x=x<<;
     }
     return true;
 }
 int main()
 {
     int n;
     int i,j,s,k,hxl;
     scanf("%d",&n);
     {
         for(i=; i<=n; i++)
             for(j=; j<=n; j++)
                 scanf("%d",&a[i][j]);
         memset(now,,sizeof(now));
         memset(before,,sizeof(before));
         k=<<n;
         for(i=; i<=n; i++)
         {
             prepare(i,n);
             for(j=; j<k; j++)
                 if(panduan(j,n))
                 {
                     hxl=;
                     for(s=; s<k; s++)
                     {
                         if( (s&j)> ) continue;
                         if(before[s]>hxl)
                             hxl=before[s];
                     }
                     dp1[j]=dp1[j]+hxl;
                 }
             for(j=; j<k; j++)
             {
                 now[j]=dp1[j];
                 before[j]=now[j];
             }
         }
         hxl=;
         for(i=; i<k; i++)
             if(now[i]>hxl) hxl=now[i];

         printf("%d\n",hxl);
     }
     return ;
 }

优化：

　　很多地方可以优化。

　　1.其实，可以预处理相邻的情况。不要每一次都判断。就像打表一样。//怎么处理的呢？具体看一下代码。

　　2.预处理相邻的情况后，发现，1<<20的数组，满足条件的只有17711种，这样的话，优化就巨大了。

　  3.滚动数组。

我的代码，还是不够优化的，960ms

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>

 int a[][];
 int state[],len;
 int dp[<<],befor[<<];

 void make_init()//预处理，所以的状态
 {
     int i,k;
     k=<<;
     len=;
     for(i=;i<k;i++)
     {
         if( (i&(i<<))> ) continue;
         else state[len++]=i;
     }
 }
 void prepare(int r,int n)//处理每一行的dp值.
 {
     int i,j,k,ans,x;
     k=<<n;

     for(j=;state[j]<k;j++)
     {
         i=state[j];
         dp[i]=;
         x=i;
         ans=;
         while(x)
         {
             if(x&) dp[i]=dp[i]+a[r][ans];
             ans++;
             x=x>>;
         }
     }
 }

 int main()
 {
     int n;
     int i,j,k,s,hxl;
     make_init();
     while(scanf("%d",&n)>)
     {
         for(i=;i<=n;i++)
         for(j=;j<=n;j++)
         scanf("%d",&a[i][j]);

         k=<<n;
         memset(befor,,sizeof(befor));
         for(i=;i<=n;i++) //枚举每一行
         {
             prepare(i,n);
             for(j=;state[j]<k;j++)//枚举每一种 有效 状态
             {
                 hxl=;
                 for(s=;state[s]<k;s++)//上一行的有效状态
                 {
                     if( (state[j]&state[s]) >) continue;//没有冲突
                     if(befor[state[s]]>hxl)
                     hxl=befor[state[s]];
                 }
                 dp[state[j]]=dp[state[j]]+hxl;
             }
             for(j=;state[j]<k;j++)
             {
                 befor[state[j]]=dp[state[j]];
             }
         }
         hxl=;
         for(i=;state[i]<k;i++)
         if(hxl<befor[state[i]]) hxl=befor[state[i]];
         printf("%d\n",hxl);
     }
     return ;
 }

进一步的优化：

　　看了一下，别人的博客，看到一个很别人开的数组是很小的。why?

我开的dp数组是 dp[1<<22]，其实只要开dp[17715];和状态state[17715 ]一样就可以了.

为什么可以呢？

简单说明一下：原来的方法，是和最原始的位置是一一对应，所以，很好理解。

但是，有很多的空间是浪费的。

现在是对应状态一一对应，就是这样。这样数组开的就小很多了。而且速度快一些。

921ms  -->   486 ms

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>

 int a[][];
 int state[],len;
 int dp[],befor[];

 void make_init()//预处理，所以的状态
 {
     int i,k;
     k=<<;
     len=;
     for(i=;i<k;i++)
     {
         if( (i&(i<<))> ) continue;
         else state[len++]=i;
     }
 }
 void prepare(int r,int n)//处理每一行的dp值.
 {
     int j,k,ans,x;
     k=<<n;

     memset(dp,,sizeof(dp));
     for(j=;state[j]<k;j++)
     {
         x=state[j];
         ans=;
         while(x)
         {
             if(x&) dp[j]=dp[j]+a[r][ans];//!!!哈哈。
             ans++;
             x=x>>;
         }
     }
 }

 int main()
 {
     int n;
     int i,j,k,s,hxl;
     make_init();
     while(scanf("%d",&n)>)
     {
         for(i=;i<=n;i++)
         for(j=;j<=n;j++)
         scanf("%d",&a[i][j]);

         k=<<n;
         memset(befor,,sizeof(befor));
         for(i=;i<=n;i++) //枚举每一行
         {
             prepare(i,n);
             for(j=;state[j]<k;j++)//枚举每一种 有效 状态
             {
                 hxl=;
                 for(s=;state[s]<k;s++)//上一行的有效状态
                 {
                     if( (state[j]&state[s]) >) continue;//没有冲突
                     if(befor[s]>hxl)
                     hxl=befor[s];
                 }
                 dp[j]=dp[j]+hxl;
             }
             for(j=;state[j]<k;j++)
             {
                 befor[j]=dp[j];
             }
         }
         hxl=;
         for(i=;state[i]<k;i++)
         if(hxl<befor[i]) hxl=befor[i];
         printf("%d\n",hxl);
     }
     return ;
 }