hdu1565 状态压缩~最优值

本文探讨了一种优化网络流算法应用于解决状态转移问题的方法,通过引入状态记录和权值和优化,实现从朴素三重循环到高效算法的转变。详细介绍了算法的优化过程、关键步骤和性能提升,旨在提供一种有效的解决复杂状态转移问题的策略。

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

先dfs出两行可转移得状态,一开始用朴素的三重循环写3500MS+,感觉应该是数据比较水,看了队友的网络流代码0MS过,甚是不爽,应该优化一下,再开了一个数组记录每一行状态权值之和,优化后560MS+,只是空间有点大了。大笑


ACcode:

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int NS=21;

int n,sum;
int dp[2][1<<NS],g[NS][NS];
int state[1<<NS][2],top;
int c[1<<NS],tmp[1<<NS];

void dfs(int pos,int pre,int now)
{
    if (pos>=n)
    {
        tmp[top]=now;
        state[top][0]=pre;
        state[top++][1]=now;
        return ;
    }
    int x=pre&1,y=now&1;
    dfs(pos+1,pre<<1,now<<1);
    if (!x) dfs(pos+1,pre<<1|1,now<<1);
    if (!y) dfs(pos+1,pre<<1,now<<1|1);
}

void init(int x)
{

    for (int lim=(1<<n),i=0;i<lim;i++)
    dp[x][i]=-1,c[i]=0;
}

int Max(int a1,int b1)
{
    return a1>b1?a1:b1;
}

int main()
{
    int now,pre,s,t,w;
    while (~scanf("%d",&n))
    {
        int lim=1<<n;
        sum=top=0,dfs(0,0,0);
        sort(tmp,tmp+top);
        for (int i=1;i<top;i++)
        if (tmp[i]!=tmp[i-1])
        tmp[sum++]=tmp[i];
        memset(g,0,sizeof(g));
        for (int i=0;i<n;i++)
        for (int j=0;j<n;j++)
        scanf("%d",&g[i][j]);

        pre=1,now=0;
        init(now);
        dp[now][0]=0;
        for (int i=0;i<=n;i++)
        {
            pre^=1,now^=1;
            init(now);
            for (int k=0;k<sum;k++)
            {
                t=tmp[k];
                for (int j=0;j<n;j++)
                if (t&(1<<j))
                c[t]+=g[i][j];
            }

            for (int j=0;j<top;j++)
            {
                s=state[j][0],t=state[j][1];
                if (dp[pre][s]==-1) continue;
                w=dp[pre][s]+c[t];
                dp[now][t]=Max(dp[now][t],w);
            }
        }
        printf("%d\n",dp[now][0]);
    }
    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),空间复杂度同样取决于输入规模大小。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值