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[21][21];
int dp1[1<<21],before[1<<21],now[1<<21];

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

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

 

 优化：

　　很多地方可以优化。

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

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

 　  3.滚动数组。

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

     

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

int a[22][22];
int state[17715],len;
int dp[1<<22],befor[1<<22];

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

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

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

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

 

进一步的优化：

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

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

为什么可以呢？

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

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

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

921ms  -->   486 ms

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

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

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

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

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

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