zoj 3213 Beautiful Meadow

最新推荐文章于 2019-01-08 08:30:00 发布
最新推荐文章于 2019-01-08 08:30:00 发布
阅读量122 收藏
点赞数

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3213

题目大意：求最大简单回路。

题目思路：插头dp,增加独立插头，有可不走点需要特殊处理一下。这个题写得相当纠结啊，写括号表示法的时候有一个地方忘了处理了，花了一晚上都没调出来，今早上用最小表示法打数据对比才找到了错误，真是相当辛苦啊，不过括号表示法的效率依然不错，跑了80ms。

最小表示法：

#include<stdio.h>
#include<string.h>
#define Max 20000
#define Hash 3007
#define  __int64 long long
int code[15],ch[15],mp[15][15],ex,ey,n,m,cur,ans,num;
char str[15];
inline int max(int a,int b)
{
    return a>b?a:b;
}
struct node
{
    int size,next[Max],p[Hash],f[Max];
    __int64 state[Max];
    inline void init()
    {
        memset(p,-1,sizeof(p));
        size=0;
    }
    inline void push(__int64 st,int val)
    {
        int i,u=st%Hash;
        for(i=p[u];i!=-1;i=next[i])
        {
            if(state[i]==st)
            {
                if(val>f[i]) f[i]=val;
                return;
            }
        }
        state[size]=st;f[size]=val;
        next[size]=p[u];
        p[u]=size++;
    }
}dp[2];
inline void decode(__int64 st)
{
    memset(ch,0,sizeof(ch));
   num=st&7;
   st>>=3;
    for(int i=m;i>=0;i--)
    {
        code[i]=st&7;
        st>>=3;
    }
}
inline __int64 encode()
{
    __int64 st=0;
    int cnt=1;
    memset(ch,-1,sizeof(ch));
    ch[0]=0;
    for(int i=0;i<=m;i++)
    {
        if(ch[code[i]]==-1)
            ch[code[i]]=cnt++;
        st<<=3;
        st|=ch[code[i]];
    }
    st<<=3;
    st|=num;
    return st;
}
inline void shift()
{
    for(int k=0;k<dp[cur].size;k++)
    {
        num=dp[cur].state[k]&7;
        dp[cur^1].push((dp[cur].state[k]>>3)|num,dp[cur].f[k]);
    }
}
inline void dpblank(int i,int j)
{
    int k,l,left,up;
    for(k=0;k<dp[cur].size;k++)
    {
        int tmp=dp[cur].f[k]+mp[i][j];
        decode(dp[cur].state[k]);
        left=code[j-1],up=code[j];
        if(left&&up)
        {
            if(left!=up)
            {
                code[j-1]=code[j]=0;
                for(l=0;l<=m;l++)
                    if(code[l]==up)
                        code[l]=left;
                dp[cur^1].push(encode(),tmp);
            }
        }
        else if(left||up)
        {

            if(mp[i][j+1])
            {
                code[j-1]=0;code[j]=left+up;
                dp[cur^1].push(encode(),tmp);
            }
            if(mp[i+1][j])
            {
                code[j-1]=left+up,code[j]=0;
                dp[cur^1].push(encode(),tmp);
            }
            if(num<2)
            {
                num++;
                code[j-1]=code[j]=0;
                dp[cur^1].push(encode(),tmp);
            }
        }
        else
        {
            code[j-1]=code[j]=0;
            dp[cur^1].push(encode(),dp[cur].f[k]);
            if(mp[i][j+1]&&mp[i+1][j])
            {
                code[j-1]=code[j]=7;
                dp[cur^1].push(encode(),tmp);
            }
            if(num<2)
            {
                num++;
                if(mp[i][j+1])
                {
                    code[j-1]=0,code[j]=7;
                    dp[cur^1].push(encode(),tmp);
                }
                if(mp[i+1][j])
                {
                    code[j-1]=7,code[j]=0;
                    dp[cur^1].push(encode(),tmp);
                }
            }
        }
    }
}
void solve()
{
    int i,j,k;
    cur=0;
    dp[0].init();
    dp[0].push(0,0);
    for(i=1;i<=n;i++)
    {
        dp[cur^1].init();
        shift();
        cur^=1;
        for(j=1;j<=m;j++)
        {
            if(mp[i][j])
            {
                dp[cur^1].init();
                dpblank(i,j);
                cur^=1;
            }
        }
    }
    for(k=0;k<dp[cur].size;k++)
        if(ans<dp[cur].f[k])
            ans=dp[cur].f[k];
    printf("%d\n",ans);
}
int main()
{
    int i,j,t;
  //  freopen("D:/out.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        scanf("%d%d",&n,&m);
        ex=0;
        memset(mp,0,sizeof(mp));
        for(i=1;i<=n;i++)
           for(j=1;j<=m;j++)
           {
                scanf("%d",&mp[i][j]);
                ans=max(ans,mp[i][j]);
           }
        solve();
    }
    return 0;
}

括号表示法：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define Max 20010
#define Hash 3007
int n,m,ex,ey,cur,mp[15][15],a1,a2,a3,b1,b2,b3,ans,num;
int stack[15],f[15];
char str[15];
struct node
{
    int size,next[Max],p[Hash],state[Max];
    int f[Max];
    inline void init()
    {
        memset(p,-1,sizeof(p));
        size=0;
    }
    inline void push(int st,int val)
    {
        int i,u=st%Hash;
        for(i=p[u];i!=-1;i=next[i])
        {
            if(state[i]==st)
            {
                if(f[i]<val) f[i]=val;
                return;
            }
        }
        state[size]=st;f[size]=val;
        next[size]=p[u];
        p[u]=size++;
    }
}dp[2];
inline void decode(int st)
{
    int top=0;
    st>>=2;
    for(int i=0;i<=m;i++)
    {
        if((st&3)==1)
            stack[top++]=i;
        else if((st&3)==2)
        {
            f[stack[top-1]]=i+1;
            f[i]=stack[top-1]+1;
            top--;
        }
        st>>=2;
    }
}
inline void shift()
{
    for(int k=0;k<dp[cur].size;k++)
    {
        num=dp[cur].state[k]&3;
        dp[cur].state[k]^=num;
        dp[cur^1].push((dp[cur].state[k]<<2)|num,dp[cur].f[k]);
    }
}
inline void dpblank(int i,int j)
{
    int k,left,up;
    for(k=0;k<dp[cur].size;k++)
    {
       	int st=dp[cur].state[k];
        int tmp=dp[cur].f[k]+mp[i][j];
        left=st&a3;up=st&b3;num=st&3;
        if(left&&up)
        {
            decode(st);
            if(left==a2&&up==b1)
                dp[cur^1].push(st^left^up,tmp);
            else if(left==a1&&up==b1)
                dp[cur^1].push(st^left^up^(3<<(2*f[j])),tmp);
            else if(left==a2&&up==b2)
                dp[cur^1].push(st^left^up^(3<<(2*f[j-1])),tmp);
            else if(left==a3&&up==b3)
                dp[cur^1].push(st^left^up,tmp);
            else if(left==a3)
                dp[cur^1].push((st^left^up)|(3<<(2*f[j])),tmp);
            else if(up==b3)
                dp[cur^1].push((st^left^up)|(3<<(2*f[j-1])),tmp);
        }
        else if(left)
        {
            if(mp[i][j+1])
                dp[cur^1].push((st^left)|(left<<2),tmp);
            if(mp[i+1][j])
                dp[cur^1].push(st,tmp);
            if(num<2)
            {
                num++;decode(st);
				int ss=(st^left^up)|num;
				if(left!=a3)
					ss|=3<<(2*f[j-1]);
                dp[cur^1].push(ss,tmp);
            }
        }
        else if(up)
        {
            if(mp[i][j+1])
                dp[cur^1].push(st,tmp);
            if(mp[i+1][j])
                dp[cur^1].push((st^up)|(up>>2),tmp);
            if(num<2)
            {
                num++;decode(st);
				int ss=(st^left^up)|num;
				if(up!=b3)
					ss|=3<<(2*f[j]);
                dp[cur^1].push(ss,tmp);
            }
        }
        else
        {
            dp[cur^1].push(st^left^up,dp[cur].f[k]);
            if(mp[i][j+1]&&mp[i+1][j])
                dp[cur^1].push(st|a1|b2,tmp);
            if(num<2)
            {
                num++;
                if(mp[i][j+1])
                dp[cur^1].push((st|b3)|num,tmp);
                if(mp[i+1][j])
                dp[cur^1].push((st|a3)|num,tmp);
            }
        }
    }
}
inline void solve()
{
    int i,j,k;
    cur=0;
    dp[0].init();
    dp[0].push(0,0);
    for(i=1;i<=n;i++)
    {
        dp[cur^1].init();
        shift();
        cur^=1;
        b1=4;b2=8;
        for(j=1;j<=m;j++)
        {
            a1=b1;a2=b2;a3=a1|a2;
            b1<<=2;b2<<=2;b3=b1|b2;
            if(mp[i][j])
            {
                dp[cur^1].init();
                dpblank(i,j);
                cur^=1;
            }
        }
    }
     for(k=0;k<dp[cur].size;k++)
        if(ans<dp[cur].f[k])
            ans=dp[cur].f[k];
    printf("%d\n",ans);
}
int main()
{
    int i,j,t;
   //freopen("D:/out2.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        scanf("%d%d",&n,&m);
        memset(mp,0,sizeof(mp));
        for(i=1;i<=n;i++)
           for(j=1;j<=m;j++)
           {
                scanf("%d",&mp[i][j]);
                if(ans<mp[i][j]) ans=mp[i][j];
           }
        solve();
    }
    return 0;
}

括号表示法的另一种写法（不加独立插头个数限制）：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define Max 20010
#define Hash 3007
int n,m,ex,ey,cur,mp[15][15],a1,a2,a3,b1,b2,b3,ans;
int stack[15],f[15];
char str[15];
struct node
{
    int size,next[Max],p[Hash],state[Max];
    int f[Max];
    inline void init()
    {
        memset(p,-1,sizeof(p));
        size=0;
    }
    inline void push(int st,int val)
    {
        int i,u=st%Hash;
        for(i=p[u];i!=-1;i=next[i])
        {
            if(state[i]==st)
            {
                if(f[i]<val) f[i]=val;
                return;
            }
        }
        state[size]=st;f[size]=val;
        next[size]=p[u];
        p[u]=size++;
    }
}dp[2];
inline void decode(int st)
{
    int top=0;
    for(int i=0;i<=m;i++)
    {
        if((st&3)==1)
            stack[top++]=i;
        else if((st&3)==2)
        {
            f[stack[top-1]]=i;
            f[i]=stack[top-1];
            top--;
        }
        st>>=2;
    }
}
inline void shift()
{
    for(int k=0;k<dp[cur].size;k++)
        dp[cur^1].push((dp[cur].state[k]<<2),dp[cur].f[k]);
}
inline void dpblank(int i,int j)
{
    int k,left,up;
    for(k=0;k<dp[cur].size;k++)
    {
       	int st=dp[cur].state[k];
        int tmp=dp[cur].f[k]+mp[i][j];
        left=st&a3;up=st&b3;
        if(left&&up)
        {
            decode(st);
            if(left==a2&&up==b1)
                dp[cur^1].push(st^left^up,tmp);
            else if(left==a1&&up==b1)
                dp[cur^1].push(st^left^up^(3<<(2*f[j])),tmp);
            else if(left==a2&&up==b2)
                dp[cur^1].push(st^left^up^(3<<(2*f[j-1])),tmp);
            else if(left==a3&&up==b3)
            {
                if((st^left^up)==0&&ans<tmp) ans=tmp;
            }
            else if(left==a3)
                dp[cur^1].push((st^left^up)|(3<<(2*f[j])),tmp);
            else if(up==b3)
                dp[cur^1].push((st^left^up)|(3<<(2*f[j-1])),tmp);
        }
        else if(left)
        {
            if(mp[i][j+1])
                dp[cur^1].push((st^left)|(left<<2),tmp);
            if(mp[i+1][j])
                dp[cur^1].push(st,tmp);
            if(left!=a3)
            {
                decode(st);
                dp[cur^1].push((st^left^up)|(3<<(2*f[j-1])),tmp);
            }
            if(left==a3)
            {
                if((st^left^up)==0&&ans<tmp) ans=tmp;
            }

        }
        else if(up)
        {
            if(mp[i][j+1])
                dp[cur^1].push(st,tmp);
            if(mp[i+1][j])
                dp[cur^1].push((st^up)|(up>>2),tmp);
            if(up!=b3)
            {
                decode(st);
                dp[cur^1].push((st^left^up)|(3<<(2*f[j])),tmp);
            }
            if(up==b3)
            {
                if((st^left^up)==0&&ans<tmp) ans=tmp;
            }
        }
        else
        {
            dp[cur^1].push(st^left^up,dp[cur].f[k]);
            if(mp[i][j+1]&&mp[i+1][j])
                dp[cur^1].push(st|a1|b2,tmp);
            if(mp[i][j+1])
                dp[cur^1].push((st|b3),tmp);
            if(mp[i+1][j])
                dp[cur^1].push((st|a3),tmp);
        }
    }
}
inline void solve()
{
    int i,j;
    cur=0;
    dp[0].init();
    dp[0].push(0,0);
    for(i=1;i<=n;i++)
    {
        dp[cur^1].init();
        shift();
        cur^=1;
        b1=1;b2=2;
        for(j=1;j<=m;j++)
        {
            a1=b1;a2=b2;a3=a1|a2;
            b1<<=2;b2<<=2;b3=b1|b2;
            if(mp[i][j])
            {
                dp[cur^1].init();
                dpblank(i,j);
                cur^=1;
            }
        }
    }
    printf("%d\n",ans);
}
int main()
{
    int i,j,t;
   //freopen("D:/out2.txt","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        scanf("%d%d",&n,&m);
        memset(mp,0,sizeof(mp));
        for(i=1;i<=n;i++)
           for(j=1;j<=m;j++)
           {
                scanf("%d",&mp[i][j]);
                if(ans<mp[i][j]) ans=mp[i][j];
           }
        solve();
    }
    return 0;
}



iteye_6233
关注
ZOJ 3213 Beautiful Meadow
imut zcy,I promise You.
05-13 535
求简单路径。得到最大的分数。 用最小表示法，需要增加标志位记录独立插头个数。要使独立插头个数小于等于2.
ZOJ 3213 Beautiful Meadow（插头DP）
GODSPEED
09-10 466
题意：在一个棋盘模型上求最大权值的路径，路径的起点和终点可以任意选定。 思路：相比于普通的回路DP，增加一个状态表示独立插头，即起点和终点，这道题分的情况比较多。 默默吐槽...代码量5000b写4个小时调试4个小时，分类讨论简直恶心到吐.....一不小心就wa了....... #include #include #include #include #include #include #in
ZOJ 3213 Beautiful Meadow 解题报告（插头DP）
SF-_- 的 ACM 博客
11-13 1473
Beautiful Meadow Time Limit: 5 Seconds      Memory Limit: 32768 KB Tom's Meadow Tom has a meadow in his garden. He divides it into N * M squares. Initially all the squares are covered with
[ZOJ3213] Beautiful Meadow
weixin_30706691的博客
05-15 99
　　插头DP。。。网格图，有障碍，格子上有权值，求总权值最大的简单路径。 　　因为路径的起始点不确定。。所以多开一维表示当前已经有多少个独立插头。。 　　只要不合并相同的联通块，并且已经用了2个独立插头，那就是一条简单路径了。。。 　　需要特判路径上只有一个点的情况。 1 #include<cstdio> 2 #include<iostream> ...
ZOJ3213-Beautiful Meadow
dengtan9179的博客
09-14 391
题意 有一个 \(n\times m\) 的方格纸，每个格子要么不能走，要么有一个权值。求一条简单路径权值和最大。简单路径是指不相交，不经过同一个格子的一条路经。\(n,m\le 8\) 。 分析 既然是路径，就要用到独立插头。这题的问题在于 起点终点不确定 。 不确定起点终点，关系到两种情况的处理。第一种是当前转移格子没有左插头和上插头。 格子可以不走，所以可以直接转移到 \(a=b...
ZOJ 3213 Beautiful Meadow（插头DP-一条路径最大值，不固定头尾）
weixin_33725239的博客
01-08 135
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3396 题意：给定一个n*m的寻宝图。有些位置不能走，其余位置每个位置都有一个宝藏。从一个位置出发到另一个位置结束（这两个位置都是可以自己选择的），每个格子最多走一次。求最大价值。 思路：第一道头尾不固定的单路径。增加了一个Num，表示当前已经使用的独立插头的数目，...
zoj 3213 Beautiful Meadow(插头dp)
ACM之梦
01-30 595
题意： 给图地图，每个格子有分数，0分数的格子不能走。求最大分数的一条路径 题解： 这题异常坑爹，在换行操作、有过移位的操作中可能会误将最高位的标记为覆盖掉，因此注释的地方是改写了的，注意区别。 /** 积累一个小技巧，队友路径的插头dp大概分为两种大类 一：只给定起点或终点、起点和终点都给定 对于这类要在总的装填转移之前加特判终点和起点的代码 二：没给起点终点 这
zoj 1002_zoj1002_
09-29
【标题】"ZOJ 1002" 是一个在线编程竞赛题目，源自ZOJ（Zhejiang Online Judge），这是一个面向ACM/ICPC（国际大学生程序设计竞赛）的在线评测系统。题目编号1002，通常表示该题是ZOJ平台上的一个问题，可能涉及算法...
zoj.gz_ ZOJ_ZOJ 1016_max flow_zoj 1045_zoj.rar
09-24
标题中的"ZOJ.gz_ ZOJ_ZOJ 1016_max flow_zoj 1045_zoj.rar" 提到了两个ZOJ（Zhejiang Online Judge）的题目，分别是1016和1045，这两个数字通常代表在线编程竞赛中的题目编号。这些题目通常涉及到算法和数据结构的...
zoj.rar_zoj_zoj4041
09-23
《ZOJ 4041问题的正确解法与程序分析》 ZOJ（Zhejiang Online Judge）是一个知名的在线编程竞赛平台，其中的题目编号为4041的题目吸引了众多程序员的关注。本篇文章将深入探讨ZOJ 4041的正确解法，并对提供的源代码...
ZOJ.zip_Jugs A_ZOJ NTA_zoj acm_zoj acm 1216_zoj code
09-20
【ZOJ.zip】是一个压缩包，里面包含了与ZOJ（Zhejiang Online Judge）相关的ACM（International Collegiate Programming Contest）题解。ZOJ是一个在线编程竞赛平台，它为参赛者提供了一系列算法题目进行练习，以...
ZOJ1014.zip_zoj code_zoj1004
09-23
标题“ZOJ1014.zip_zoj code_zoj1004”表明这是一个与ZOJ（ZeroJudge）在线判题系统相关的代码压缩包，其中可能包含了解决ZOJ问题1004的源代码。ZOJ是面向编程爱好者和学生的一个在线编程竞赛平台，它提供了各种算法...
1基于STM32的智能气象站项目.docx
最新发布
10-30
1基于STM32的智能气象站项目
技术资料分享SH-HC-05蓝牙模块技术手册很好的技术资料.zip
10-30
技术资料分享SH-HC-05蓝牙模块技术手册很好的技术资料.zip
【路径规划】改进的人工势场算法机器人避障路径规划【含Matlab源码 1151期】.zip
10-30
【路径规划】改进的人工势场算法机器人避障路径规划【含Matlab源码 1151期】.zip
链表HuffmanTree.zip
10-30
链表HuffmanTree.zip
开题报告Nodejs商城系统.docx
10-30
毕业设计开题报告
【路径规划】 A_star算法机器人走迷宫路径规划【含Matlab源码 1332期】.zip
10-30
【路径规划】 A_star算法机器人走迷宫路径规划【含Matlab源码 1332期】.zip
Zoj4041题解及运行程序代码分析
资源摘要信息:"zoj.rar_zoj_zoj4041" 知识点: 1. ZOJ简介：ZOJ是浙江大学在线评测系统的缩写，它是一个为程序设计竞赛提供在线自动评测的系统，广泛应用于学校内或者各编程竞赛中。用户可以通过提交自己的代码来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值