HDU1565:方格取数(1) (状态压缩DP)

本文介绍了一种解决棋盘非邻接子集最大和问题的方法,使用二进制记录每一步的选择状态,通过动态规划算法计算出在给定的n*n棋盘中,选取非相邻格子内的数值,使总和达到最大。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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
 

 

与HDU1074有点相似,还是用二进制来记录表示取或者不取,一行行的进行计算,用一个数组记录上一行的所有取法,一个数组记录现在这行的所有取法,如果取法进行与运算为1的话,那么就代表有相邻的而不进行计算,然后这样一直DP到最后一行便可以得到最后的结果

 

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

const int L = 20000;
int n,a[20][20];
int dp[L],tem[L];
int now[L],pre[L];
int ans[L],pre_size,now_size;

void dfs(int id,int k,int p,int sum)
{
    if(k>=n)//超过n则可以记录这个状态
    {
        now[++now_size] = p;
        ans[now_size] = sum;
        return ;
    }
    dfs(id,k+2,p|(1<<k),sum+a[id][k]);//这个位置取了,那么就要加上这个位的二进制,通过或运算得出,这个位置取了的话,那么下一个要取的至少要跳两格
    dfs(id,k+1,p,sum);//这个位置不取并跳一格
}

void DP()
{
    int i,j,k;
    for(k = 1; k<=n; k++)
    {
        now_size = 0;
        dfs(k,0,0,0);//搜出此行的所有状态
        for(i = 1; i<=now_size; i++)
            dp[i] = 0;
        for(i = 1; i<=now_size; i++)
        {
            for(j = 1; j<=pre_size; j++)
            {
                if(now[i]&pre[j]) continue;//相与为1,证明有相邻而不继续往下
                dp[i] = max(dp[i],tem[j]+ans[i]);
            }
        }
        for(i = 1; i<=now_size; i++)//目前这行的状态保存为上一行
        {
            tem[i] = dp[i];
            pre[i] = now[i];
        }
        pre_size = now_size;
    }
}

int main()
{
    int i,j;
    while(~scanf("%d",&n))
    {
        for(i = 1; i<=n; i++)
            for(j = 0; j<n; j++)
                scanf("%d",&a[i][j]);
        tem[1] = pre[1] = 0;//先取一个,但是位置并不确定,
        pre_size = 1;
        DP();
        int ans = 0;
        for(i = 1;i<=pre_size;i++)
        ans = max(ans,tem[i]);
        printf("%d\n",ans);
    }

    return 0;
}


 

### HDU1565 方格 动态规划 解题思路 对于给定的一个 \( n \times n \) 的棋盘,其中每个格子内含有一个非负值。目标是从这些格子里选一些,使得任何两个被选中的所在的位置没有公共边界(即它们不是上下左右相邻),并且使选出的之和尽可能大。 #### 构建状态转移方程 为了实现这一目的,可以定义二维组 `dp` 来存储到达某位置的最大累积值: - 设 `dp[i][j]` 表示当考虑到第 i 行 j 列时能够获得的最大价值。 初始化阶段,设置第一行的据作为基础情况处理;之后通过遍历整个矩阵来更新每一个可能的状态。具体来说,在计算某个特定单元 `(i, j)` 处的结果之前,应该先考察其上方以及左上角、右上角三个方向上的元素是否已经被访问过,并据此调整当前节点所能达到的最佳得分[^1]。 ```cpp for (int i = 0; i < N; ++i){ for (int j = 0; j < M; ++j){ dp[i][j] = grid[i][j]; // 上面一排的情况 if(i > 0 && !conflict(i,j,i-1,j)) dp[i][j] = max(dp[i][j], dp[i-1][j] + grid[i][j]); // 左斜线方向 if(i > 0 && j > 0 && !conflict(i,j,i-1,j-1)) dp[i][j] = max(dp[i][j], dp[i-1][j-1] + grid[i][j]); // 右斜线方向 if(i > 0 && j+1 < M && !conflict(i,j,i-1,j+1)) dp[i][j] = max(dp[i][j], dp[i-1][j+1] + grid[i][j]); } } ``` 这里需要注意的是冲突检测函 `conflict()` ,用于判断两格之间是否存在直接连接关系。如果存在,则不允许同时选择这两格内的字相加到路径之中去。 #### 寻找最优解 最终的答案将是最后一行中所有列的最大值之一,因为这代表了从起点出发直到终点结束可以获得的最大收益。可以通过简单的循环找到这个最大值并返回它作为结果输出。 ```cpp // 找到最后一行的最大值 __int64 result = 0; for(int col = 0; col < M; ++col) { result = max(result, dp[N-1][col]); } cout << "Maximum sum is: " << result << endl; ``` 上述方法利用了动态规划的思想有效地解决了该问题,时间复杂度大约为 O(n*m),空间复杂度同样决于输入规模大小。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值