U - 方格取数(1)

U - 方格取数(1)

Time Limit:5000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Submit  Status

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进行转移

dp[i][j]表示第i排的j状态时的最优解，那么可以枚举j，对于每一个j枚举上一排的k，如果不会冲突那么进行转移。

实际上因为n <= 20 这种方法的复杂度为 18000*18000*20*20 （一共18000种可行状态，20排，从状态转变成数时有一个约为20的循环），题目给了5s是绝对不可能过的，这需要的时间大概是接近半个小时，但是因为数据太水，居然能卡过去。

#include"iostream"
#include"cstring"
#include"cstdio"
#include"algorithm"

#define LL __int64

using namespace std;

LL maze[25][25];
LL mode[20005];
LL dp[25][20005];
LL num;

bool judge(LL x)
{
    LL x1 = x << 1;
    LL x2 = x >> 1;
    if((x&x1) == 0 && (x&x2) == 0) return true;
    return false;
}

void init()
{
    num = 0;
    for(int i = 0;i <= (1<<20);i++)
    {
        if(judge(i)) mode[num++] = i;
    }
}

LL fun(LL line,LL x)
{
    LL tot = 0;
    int pos = 1;
    while(x > 0)
    {
        tot += (x&1)*maze[line][pos];
        pos ++;
        x >>= 1;
    }
    return tot;
}

int main(void)
{
    int n;
    init();
    while(~scanf("%d",&n))
    {
        memset(dp,0,sizeof(dp));
        for(int i = 1;i <= n;i++)
        {
            for(int j = 1;j <= n;j++)
            {
                scanf("%I64d",&maze[i][j]);
            }
        }
        LL maxn = -1;
        for(LL i = 0;mode[i] < (1<<n);i++)
        {
            dp[1][i] = fun(1,mode[i]);
            maxn = max(maxn,dp[1][i]);
        }
        for(LL i = 2;i <= n;i++)
        {
            for(LL j = 0;mode[j] < (1<<n);j++)
            {
                for(LL k = 0;mode[k] < (1<<n);k++)
                {
                    if(mode[j]&mode[k]) continue;
                    dp[i][j] = max(dp[i-1][k] + fun(i,mode[j]),dp[i][j]);
                    maxn = max(dp[i][j],maxn);
                }
            }
        }
        printf("%I64d\n",maxn);
    }
    return 0;
}