HDU2167

最新推荐文章于 2020-05-20 15:23:53 发布
最新推荐文章于 2020-05-20 15:23:53 发布
阅读量854 收藏 1
点赞数
分类专栏： ACM--题解汇总 ACM--状态压缩DP 文章标签： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013480600/article/details/20228977
版权

HDU2167Pebbles

给你一个N*N(3<=N<=15)矩阵,矩阵中每个格子都是一个两位正整数,现在要你取数,使得所取的所有数的总和最大.规则:不能取任意两个邻接的数(8个方向邻接).

分析:第i行怎么取只和第i-1行的取法有关,令d[i][S]表示第i行的取法是S时能取得最大数之和.

d[i][S]=max{d[i-1][S1] + get_v(i,S)} 其中S1和S是兼容的,get_v(i,S)得到的是第i行为状态S时从第i行能获得的数总和.

初值:d[0][S]=x,S表示第0行的所有合法状态.其他d初始化为-1,行号从0到N-1,列号也从0到N-1.

AC代码:枚举有效状态,843ms

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int d[16][1<<15];
int n;
int g[16][16];
int cnt;
int state[2000];//1<<15中共1597个合法状态
bool legal(int S)//S中没有连续的1
{
    for(int i=0;i<n-1;i++)
        if( S&(1<<i) &&S&(1<<(i+1)) )
            return false;
    return true;
}
int get_v(int i,int S)//得到第i行状态为S时取得数和
{
    int sum=0;
    for(intj=0;j<n;j++)if(S&(1<<j))
        sum += g[i][j];
    return sum;
}
bool campet(int S,int S1)//判断S和S1是否兼容
{
    if(S&S1)//对应列有1
        return false;
    else if( S&(S1<<1) )//S中列与S1中的右上角列有1
        return false;
    else if( (S<<1)&S1 )//S中列与S1中的左上角列有1
        return false;
    return true;
}
int main()
{
    char a;
    n=0;
   while(scanf("%d%c",&g[0][n++],&a)==2)//读取第一行的第一个数和它后面的一个字符
    {
       while(scanf("%d%c",&g[0][n++],&a)==2)//读取第一行的第2到n个数
        {
            if(a=='\n')
            {
                break;
            }
        }
        cnt= 0;//计数有效状态
        for(int i=1;i<n;i++)//读取第2到n行
            for(int j=0;j<n;j++)
               scanf("%d",&g[i][j]);
        for(int S=0;S<(1<<n);S++)if(legal(S))//预先求出所有有效状态
            state[cnt++]=S;
        memset(d,-1,sizeof(d));
        for(int i=0;i<cnt;i++)//求出d的第0行初值,行列号从0到n-1
        {
            int S=state[i];
            d[0][S] = 0;
            for(int j=0;j<n;j++)
            {
                if(S&(1<<j))
                    d[0][S]+=g[0][j];
            }
        }
        int sum=0;
        for(int i=1;i<n;i++)//第i行
        {
            for(int j=0;j<cnt;j++)//第i行选第j个合法状态
            {
                int S = state[j];
                for(int k=0;k<cnt;k++)//第i-1行选第k个合法状态
                {
                    int S1 = state[k];
                    if(!campet(S,S1) ||d[i-1][S1]==-1 )//不兼容或者状态S1不可到达
                        continue;
                    d[i][S] = max(d[i][S] ,d[i-1][S1]+get_v(i,S));
                    if(i==n-1) sum = max(sum ,d[i][S]);
                }
            }
        }
        printf("%d\n",sum);
        n=0;
    }
    return 0;
}


 

速度有点慢,现在用单层dfs回溯构造法来做而不是用枚举所有有效状态来做.

 
AC代码:593ms
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int d[16][1<<15];
int n,sum;
int g[16][16];
int cnt;
int state[2000];//1<<15中共1597个合法状态
bool legal(int S)//S中没有连续的1
{
    for(int i=0;i<n-1;i++)
        if( S&(1<<i) &&S&(1<<(i+1)) )
            return false;
    return true;
}
int get_v(int i,int S)//得到第i行状态为S时取得数和
{
    int sum=0;
    for(intj=0;j<n;j++)if(S&(1<<j))
        sum += g[i][j];
    return sum;
}
bool campet(int S,int S1)//判断S和S1是否兼容
{
    if(S&S1)//对应列有1
        return false;
    else if( S&(S1<<1) )//S中列与S1中的右上角列有1
        return false;
    else if( (S<<1)&S1 )//S中列与S1中的左上角列有1
        return false;
    return true;
}
void dfs(int r,int c,int S,int S1)//要在第i行选,当前第i行的状态是S,第i-1行的状态是S1
{
    if(c==n)return ;
    d[r][S] = max(d[r][S],d[r-1][S1]+get_v(r,S));//第c列不选
    if(r==n-1) sum = max(sum,d[r][S]);
 
    if( (S1&(1<<c))==0 && (c==0 || ( (S&(1<<(c-1)))==0 && (S1&(1<<(c-1)))==0 )) && ( c==n-1 || ( (S1&(1<<(c+1)))==0 ) )    )
    //第c列选,需要符合的条件:S1第c列没数且S和S1的c-1列和c+1列都没数
    {
        S+=(1<<c);
        d[r][S] =max(d[r][S],d[r-1][S1]+get_v(r,S) );//第c列选
        if(r==n-1) sum = max(sum,d[r][S]);
        dfs(r,c+1,S,S1);
        S-=(1<<c);//还原状态
    }
    dfs(r,c+1,S,S1);
}
int main()
{
    char a;
    n=0;
   while(scanf("%d%c",&g[0][n++],&a)==2)//读取第一行的第一个数和它后面的一个字符
    {
        while(scanf("%d%c",&g[0][n++],&a)==2)//读取第一行的第2到n个数
        {
            if(a=='\n')
            {
                break;
            }
        }
        cnt= 0;//计数有效状态
        for(int i=1;i<n;i++)//读取第2到n行
            for(int j=0;j<n;j++)
               scanf("%d",&g[i][j]);
        for(int S=0;S<(1<<n);S++)if(legal(S))//预先求出所有有效状态
            state[cnt++]=S;
        memset(d,-1,sizeof(d));
        for(int i=0;i<cnt;i++)//求出d的第0行初值,行列号从0到n-1
        {
            int S=state[i];
            d[0][S] = 0;
            for(int j=0;j<n;j++)
            {
                if(S&(1<<j))
                    d[0][S]+=g[0][j];
            }
        }
        sum=0;
        for(int i=1;i<n;i++)//第i行
        {
            for(int j=0;j<cnt;j++)//第i-1行选第j个合法状态
            {
                int S1 = state[j];
                if(d[i-1][S1]==-1)
                    continue;
                dfs(i,0,0,S1);
            }
        }
        printf("%d\n",sum);
        n=0;
    }
    return 0;
}


AC代码:31ms 双层回溯滚动数组+状态压缩DP

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int d[2][1<<15];
int n,sum;
int g[16][16];
int cnt;//有效状态计数
int cur;//滚动数组指针
int state[2000];//1<<15中共1597个合法状态
bool legal(int S)//S中没有连续的1
{
    for(int i=0;i<n-1;i++)
        if( S&(1<<i) && S&(1<<(i+1)) )
            return false;
    return true;
}
void dfs(int r,int c,int S,int S1,int num)//要在第r行c列,r行为S,r-1行为S1,当前r行S选的数和位num
{
    if(c==n)
    {
        d[cur][S] = max(d[cur][S],d[1-cur][S1]+num);//第c列不选
        if(r==n-1) sum = max(sum , d[cur][S]);
        return ;
    }

    if(c<=n-2)//上或下行放一个1
    {
        dfs(r,c+2,S+(1<<c),S1,num+g[r][c]);//r行放
        dfs(r,c+2,S,S1+(1<<c),num);//r-1行放
    }
    else//c列已经是最后一列了
    {
        dfs(r,c+1,S+(1<<c),S1,num+g[r][c]);//r行放
        dfs(r,c+1,S,S1+(1<<c),num);//r-1行放
    }

    dfs(r,c+1,S,S1,num);//不放
}
int main()
{
    char a;
    n=0;
    while(scanf("%d%c",&g[0][n++],&a)==2)//读取第一行的第一个数和它后面的一个字符
    {
        while(scanf("%d%c",&g[0][n++],&a)==2)//读取第一行的第2到n个数
        {
            if(a=='\n')
            {
                break;
            }
        }
        cnt= 0;//计数有效状态
        for(int i=1;i<n;i++)//读取第2到n行
            for(int j=0;j<n;j++)
                scanf("%d",&g[i][j]);
        for(int S=0;S<(1<<n);S++)if(legal(S))//预先求出所有有效状态
            state[cnt++]=S;
        memset(d,-1,sizeof(d));
        for(int i=0;i<cnt;i++)//求出d的第0行初值,行列号从0到n-1
        {
            int S=state[i];
            d[0][S] = 0;
            for(int j=0;j<n;j++)
            {
                if(S&(1<<j))
                    d[0][S]+=g[0][j];
            }
        }
        sum=0;
        cur=0;
        for(int i=1;i<n;i++)//第i行
        {
            cur=1-cur;
            dfs(i,0,0,0,0);
        }
        printf("%d\n",sum);
        n=0;
    }
    return 0;
}


focus_best
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ HDU 2000
09-15
#include using namespace std; int main(){ char a[2]; while(cin>>a){ int temp; for(int i=0; i; i++) for(int j=0;j;j++) if(a[i]>a[i+1]) { temp=a[i]; a[i]=a[i+1]; a[i+1]=temp;...}
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
HDU2167 Pebbles（状压DP）
dengliugong3918的博客
02-13 89
题目给一张n×n的格子，每个格子都有数字，要从格子中取若干个数字，八个方向相邻的数字不能一起取，问取的数字最大和是多少。 从第一行一行一行看下去，可以发现第1行取哪几列只会影响到第2行，第3行后面的一点影响都没有。即第i行的决策只受i-1行决策的影响。 那么自然想到状态DP—— dp[i][S]前i行其中第i行取的列的集合是S的取数最大和 dp[i][S]=max(dp[i-...
hdu2167(压缩DP)
hndu__lz的博客
06-05 484
Problem Description You’re given an unlimited number of pebbles to distribute across an N x N game board (N drawn from [3, 15]), where each square on the board contains some positive point value betwe
hdu2167 方格取数 状态压缩dp
天使也掉毛
10-03 653
题意：      方格取数，八个方向的限制。 思路：      八个方向的不能用最大流了，四个的可以，八个的不能抽象成二分图，所以目测只能 用dp来跑，dp[i][j]表示的是第i行j状态的最优，具体看代码。
hdu2167——Pebbles
Alex
10-22 990
Pebbles Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 1136    Accepted Submission(s): 661 Problem Description You're given an unlimit
[hdu2167][DP][状态压缩]Pebbles
Rose_max的博客
08-24 441
Description You’re given an unlimited number of pebbles to distribute across an N x N game board (N drawn from [3, 15]), where each square on the board contains some positive point value betwee
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
HDU2167-Pebbles(状态压缩)
weixin_43357583的博客
05-20 244
You’re given an unlimited number of pebbles to distribute across an N x N game board (N drawn from [3, 15]), where each square on the board contains some positive point value between 10 and 99, inclusive. A 6 x 6 board might look like this: The player dis
hdu 2167 Pebbles 状态压缩dp
u012342878的专栏
08-06 504
Problem Description You're given an unlimited number of pebbles to distribute across an N x N game board (N drawn from [3, 15]), where each square on the board contains some positive point value betw
[HDU2167]Pebbles(状压)[第一题]
xjwwd的博客
08-24 570
[HDU2167]Pebbles(状压)[第一题]
hdu2167之状态压缩
qq_36782366的博客
08-02 250
题目链接： 题目大意：给你一个矩阵，让你在矩阵中找一些元素使它们加起来和最大，但是当你使用某一个元素时，那么这个元素周围的其它八个元素都不能取！ 思路：当前行的状态可以由上一行推断而来，所以维护当前行和上一行即可。 需要记录上一行的状态数量，每一种的状态，和从第一行到上一行每个状态的总的元素和。 当前行的话通过dfs，求出当前行状态的个数以及每个状态下当前行的值。 之和比较上一行和当
【动态规划13】hdu2167 Pebbles（简单状压dp）
Flanoc的博客
06-11 470
状压dp+奇怪的优化
hdu2167 轮廓线动态规划
touwangyi的博客
07-19 262
相对上一题方格取数，这一题要高级很多了。首先输入比较难处理，其次周围8格数字不可取，上一题的方法不能直接使用了。因为必须要记录当前格左上角的数字有没有取得情况，我们需要在状态中加一位，并且换行时要更新一下状态。如下图： 状态记录及转移 在取11格的数字时，我们需要判断10，6，7，8格是否有取数字。在更新11格的状态的同时，丢弃掉第6格的状态值。在遇到换行时，第8格的状态可以直接丢弃
hdu 2167(状压dp)
weixin_34292287的博客
08-30 73
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2167 思路：经典的状压dp题，前后，上下，对角8个位置不能取，状态压缩枚举即可所有情况，递推关系是为dp[i][j]=max(dp[i][j],dp[i-1][k]+sum[i][j]),具体的含义见code： 1 #include&lt;iostream&gt; 2 #includ...
hdu2167 状态压缩DP入门题
zz_ylolita
02-03 214
照猫画虎写了道入门题。。讲道理这东西我不应该现在才来学TAT //状态压缩DP入门题 //九宫格的相邻限制条件 //N*N 3&lt;=N&lt;=15 /* dp[i][j]表示前i行，最后一行状态为j时得到的最大分数和 对于一行j的所有可能可以用DFS弄出来，在同行搜索的时候只要保证行不相邻。 在判断合法状态转移的时候，判断本身、左移和右移即可。 dp[i][j] = max{dp[i-1...
hdu2600java
最新发布
07-18
HDOJ（ HDU Online Judge）是一个由哈尔滨工业大学主办的在线编程竞赛平台，提供大量的算法题目供学生和编程爱好者练习和学习。编号为2600的题目可能是竞赛中的一道题目，具体的题目信息没有直接给出，通常这种类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值