HDU 3681 Prison Break 哈密顿回路DP

最新推荐文章于 2020-05-09 09:41:59 发布
最新推荐文章于 2020-05-09 09:41:59 发布
阅读量1.4k 收藏
点赞数 3
分类专栏： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waitfor_/article/details/8622112
版权
题意是已知一幅矩阵迷宫，給起点，开始时充满电，要求是遍历给定的点，每移动一次花费1，迷宫中有若干充电池可充满电（每个充电池只能用一次），求原始电量最少是多少*/

首先抽象出起点、终点、充电池，建立他们的最短路径图，二分枚举原始电量 从而转化为 哈密尔顿回路的状态DP问题 。这样建图原理是：对于原图当前用不用充电池 在新图中 我们可以用两种不同的边来表示（在新图中通过一条边移动到一个充电池则一定用此充电池，而在边上经过充电池时不用）


BFS做法（用时421ms）


#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

struct Edge{
    int v,next;
}edge[2000];
int head[300],cnt,ids,fin;

int n,m;
char map[20][20];
int id[20][20];
int c[20][2];
int dis[20][20];

struct Node{
    int s,d;
};

void init(){
    memset(head,-1,sizeof(head));
    memset(id,-1,sizeof(id));
    memset(dis,-1,sizeof(dis));
    cnt=0,ids=1,fin=0;
}
void addedge(int u,int v){
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

void bfs(int s){
    int i,j,u,v;
    struct Node tem,tem1;
    queue<struct Node>q;
    bool ok[400];
    memset(ok,0,sizeof(ok));
    tem.s=s,tem.d=0;
    q.push(tem);
    ok[s]=1;
    while(!q.empty()){
        tem=q.front();
        q.pop();
        u=tem.s;
        if(id[u/m][u%m]!=-1) dis[id[s/m][s%m]][id[u/m][u%m]]=tem.d;
        for(i=head[u];i!=-1;i=edge[i].next){
            v=edge[i].v;
            if(ok[v])continue;
            ok[v]=1;
            tem1.s=v;
            tem1.d=tem.d+1;
            q.push(tem1);
        }
    }
}
int dp[1<<16][16];
bool solve(int mid){
    int i,j,k;
    memset(dp,-1,sizeof(dp));
    dp[1][0]=mid;
    for(i=0;i<(1<<ids);i++)
        for(j=0;j<ids;j++){
            if((i&(1<<j)==0) || dp[i][j]==-1)continue;
            if((i&fin)==fin)
                return 1;
            for(k=0;k<ids;k++){
                if(i&(1<<k))continue;
                if(dis[k][j]==-1)continue;
                if(dp[i][j]>=dis[k][j]){
                    if(dp[i|(1<<k)][k]==-1 || dp[i|(1<<k)][k]<dp[i][j]-dis[k][j])
                        dp[i|(1<<k)][k]=dp[i][j]-dis[k][j];
                    if(map[c[k][0]][c[k][1]]=='G')
                        dp[i|(1<<k)][k]=mid;
                }
            }
        }
    return 0;
}
int main(){
    int i,j,k;
    while(scanf("%d %d",&n,&m) && n!=0 && m!=0){
        init();
        for(i=0;i<n;i++)
            scanf("%s",map[i]);
        for(i=0;i<n;i++)
            for(j=0;j<m;j++){
                if(map[i][j]=='D')continue;
                if(map[i][j]=='F'){
                    c[0][0]=i;
                    c[0][1]=j;
                    id[i][j]=0;
                }
                else if(map[i][j]=='G'){
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                }
                else if(map[i][j]=='Y'){
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                    fin|=(1<<(ids-1));
                }
                if(i-1>=0 && map[i-1][j]!='D')
                    addedge(i*m+j,(i-1)*m+j);
                if(i+1<n && map[i+1][j]!='D')
                    addedge(i*m+j,(i+1)*m+j);
                if(j-1>=0 && map[i][j-1]!='D')
                    addedge(i*m+j,i*m+j-1);
                if(j+1<m && map[i][j+1]!='D')
                    addedge(i*m+j,i*m+j+1);
            }
        /*for(i=0;i<ids;i++){
            for(j=0;j<ids;j++)
                printf("%d ",dis[i][j]);
            puts("");
        }
        puts("");*/
        for(i=0;i<ids;i++)
            bfs(c[i][0]*m+c[i][1]);
        int l=0,r=n*m*(ids-1),mid,ans=-1;
        while(l<=r){
            int mid=(l+r)>>1;
            if(solve(mid)){
                ans=mid;
                r=mid-1;
            }
            else
                l=mid+1;
        }
        printf("%d\n",ans);
    }
    return 0;
}

DFS做法（用时31ms）


#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

struct Edge{
    int v,next;
}edge[2000];
int head[300],cnt,ids,fin,mid;

int n,m;
char map[20][20];
int id[20][20];
int c[20][2];
int dis[20][20];

struct Node{
    int s,d;
};

void init(){
    memset(head,-1,sizeof(head));
    memset(id,-1,sizeof(id));
    memset(dis,-1,sizeof(dis));
    cnt=0,ids=1,fin=0;
}
void addedge(int u,int v){
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}

void bfs(int s){
    int i,j,u,v;
    struct Node tem,tem1;
    queue<struct Node>q;
    bool ok[400];
    memset(ok,0,sizeof(ok));
    tem.s=s,tem.d=0;
    q.push(tem);
    ok[s]=1;
    while(!q.empty()){
        tem=q.front();
        q.pop();
        u=tem.s;
        if(id[u/m][u%m]!=-1) dis[id[s/m][s%m]][id[u/m][u%m]]=tem.d;
        for(i=head[u];i!=-1;i=edge[i].next){
            v=edge[i].v;
            if(ok[v])continue;
            ok[v]=1;
            tem1.s=v;
            tem1.d=tem.d+1;
            q.push(tem1);
        }
    }
}
int has[20];
int dfs(int pos,int len,int sta){
    if((sta&fin)==fin)return 1;
    for(int i=0;i<ids;i++){
        if(has[i] || dis[pos][i]==-1)continue;
        if(len>=dis[pos][i]){
            if(map[c[i][0]][c[i][1]]=='G'){
                has[i]=1;
                if(dfs(i,mid,sta|(1<<i)))return 1;
                has[i]=0;
            }
            else{
                has[i]=1;
                if(dfs(i,len-dis[pos][i],sta|(1<<i)))return 1;
                has[i]=0;
            }
        }
    }
    return 0;
}
int main(){
    int i,j,k;
    while(scanf("%d %d",&n,&m) && n!=0 && m!=0){
        init();
        for(i=0;i<n;i++)
            scanf("%s",map[i]);
        for(i=0;i<n;i++)
            for(j=0;j<m;j++){
                if(map[i][j]=='D')continue;
                if(map[i][j]=='F'){
                    c[0][0]=i;
                    c[0][1]=j;
                    id[i][j]=0;
                }
                else if(map[i][j]=='G'){
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                }
                else if(map[i][j]=='Y'){
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                    fin|=(1<<(ids-1));
                }
                if(i-1>=0 && map[i-1][j]!='D')
                    addedge(i*m+j,(i-1)*m+j);
                if(i+1<n && map[i+1][j]!='D')
                    addedge(i*m+j,(i+1)*m+j);
                if(j-1>=0 && map[i][j-1]!='D')
                    addedge(i*m+j,i*m+j-1);
                if(j+1<m && map[i][j+1]!='D')
                    addedge(i*m+j,i*m+j+1);
            }
        for(i=0;i<ids;i++)
            bfs(c[i][0]*m+c[i][1]);
        int flag=1;
        for(i=1;i<ids;i++){
            if(map[c[i][0]][c[i][1]]=='Y')
                if(dis[0][i]==-1){
                    flag=0;
                    break;
                }
        }
        int ans=-1;
        if(flag){
            int l=0,r=n*m*(ids-1);
            while(l<=r){
                mid=(l+r)>>1;
                memset(has,0,sizeof(has));
                has[0]=1;
                if(dfs(0,mid,1)){
                    ans=mid;
                    r=mid-1;
                }
                else
                    l=mid+1;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}


Benzema67
关注
专栏目录
hdu5418 最短哈密顿回路
她山之石，决不自弃
08-23 7835
先用floyd求出每两点之间的最短路。一开始我用深搜计算最短哈密顿回路，毫无意外TLE了。 #include<iostream> #include<cstring> #include<cstdlib> #include<cstdio> #include<cmath> #include<string> #include<map> #include<set> #include<algorithm> #
HDU-2181 哈密顿绕行世界问题（dfs）
一只在校程序猿的技术贴
04-27 254
Problem Description: 一个规则的实心十二面体，它的 20个顶点标出世界著名的20个城市，你从一个城市出发经过每个城市刚好一次后回到出发的城市。 Input: 前20行的第i行有3个数,表示与第i个城市相邻的3个城市.第20行以后每行有1个数m,m<=20,m>=1.m=0退出. Output: 输出从第m个城市出发经过每个城市1次又回到m的所有路线,如有多...
poj 2288 Islands and Bridges解题报告-状态压缩dp
weixin_30908103的博客
04-17 100
题目链接：http://poj.org/problem?id=2288 题目描述：哈密尔顿路问题。n个点，每一个点有权值，设哈密尔顿路为C1C2...Cn，Ci的权值为Vi，一条哈密尔顿路的值分为三部分计算： 1.每一个点的权值之和 2.对于图中的每一条CiCi+1，加上Vi*Vi+1 3.对于路径中的连续三个点：CiCi+1Ci+2，若在图中，三点构成三角形，则要加上Vi*Vi+1*V...
团体程序设计天梯赛-练习集 -- L3-015. 球队“食物链”（状压+dfs 求哈密顿回路）
aozil_yang的博客
03-27 1292
题意： 告诉你n个球队，求一个字典序最小的食物链。 头一次听说 足球食物链，相当精彩啊= =。 思路： 赛场上用普通的dfs 骗了一些分。 但是没骗够。 因为有一个细节没挖到。 就是A战胜B 不一定是A赢B 也可能是B输给A。 可以把问题转换为求一个哈密顿回路： 这是一个NP难问题。 可以用状态压缩 + dfs 的方法来做： 相当于剪枝。 令dp[i][st] 表示第i
POJ 2288 动态规划 状压DP 特殊的哈密尔顿回路
chuizhuanrun0253的博客
05-31 384
POJ 2288 / OpenJudge 2288 特殊的哈密尔顿回路问题，外加计数DP问题，在解决哈密尔顿贿赂问题时要注意，一个节点是否能过多次。本题需要最大化的是，路过的节点的取值，相邻两个节点权值的乘积，相邻三个节点权值的乘积，如果第一个和第三个直接相互连接。状态表示为：dp[i][j]...
poj 2288 哈密顿路 状压dp
01的世界
02-26 378
题目：http://poj.org/problem?id=2288 题意：给出了n个地点和m座桥（连接顶点的），画出哈密尔顿圈并求出最大值，他们的最大值由三部分决定，1：n个地点的value值之和，2：顶点之间连接之积，3：三个（连续的）顶点之积；要求输出最大值，并且存在最大值的情况总数，同时，对于两个完全逆向的路径可以认为是同一条路径； 分析：发现每个点的状态由前面两个点确定，用DP（S
哈密尔顿路（状态压缩）
qq_35752161的博客
05-09 247
https://www.acwing.com/problem/content/93/ #include<iostream> #include<algorithm> #include<queue> #include<cmath> #include<math.h> #include<string> #include<s...
插头DP模板：哈密顿回路解析
本模板针对的是POJ2064和HDU1964这两个问题，它们都涉及到插头DP和哈密顿回路。代码定义了一个`Node`结构体，存储了四个整型变量`l`, `r`, `u`, `b`，可能对应于图中某个节点的上下左右四个方向。同时，还定义了一个...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
标题中的“DP.rar”表明这是一个关于动态规划的资料压缩包，而“DP_hdu”暗示了这些题目可能来自杭州电子科技大学（HDU）的在线编程平台。动态规划通常用于解决那些可以通过子问题的最优解来构建原问题最优解的问题...
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
pat 食物链（状态压缩求哈密顿回路）
silence401的博客
04-02 1168
状态压缩求哈密顿回路 #include using namespace std; bool dp[23][1<<21]; char s[22][22]; bool vis[35]; int ans[25]; int n,f=0; bool dfs(int now,int cur,int cnt) { ans[cnt]=now; if(cnt==n) { if(s
hdu3538(最短哈密顿路径+状态压缩)
林鸿清的blog
08-23 697
终于是到了状压DP图论，初心就是为了解决图论。 题意： 给个图，给出m个限制，a,b b这个点必须出现在a之后。 问从1出发的最短哈密顿路径（从起点出发，经过所有的点一次） 概述： 从本质理解状压DP， DP[state] [ u ] 表示已经走过的状态为state ， 且当前的节点处于 u ，那么刷表拓展，找出u节点的下一个合法节点，并且必须满足 state 和 下个节点的关...
【例题】【图论(哈密顿回路)&DP(状压)】
ANG
07-22 1902
1、 NKOJ 3707 送外卖 时间限制 : - MS 空间限制 : 65536 KB 评测说明 : 时限2000ms 问题描述 有一个送外卖的，他手上有n份订单，他要把n份东西，分别送达n个不同的客户的手上。n个不同的客户分别在1~n个编号的城市中。送外卖的从0号城市出发，然后n个城市都要走一次（一个城市可以走多次），最后还要回到0点（他的单位），请问最短时间是多少。现在已知任
Hamilton-哈密顿回路
Veyron_wu
02-15 9031
哈密顿回路图，与欧拉回路图正好互相呼应，欧拉回路要求通过每条边一次且仅仅一次，而哈密顿回路图则要求通过每个顶点一次且仅仅一次。       哈密顿回路图有一个重要的问题：traveling salesperson problem,TSP，就是所谓的 *货郎担* 的问题-->要求在图中发现经过所有顶点且总距离最短的路线。（这里说的距离是路径上所有边的权的总和。而不是路的长度）       据现在
最小汉密尔顿回路问题 状态压缩dp
点羽染墨
05-01 1833
给定n个顶点做成的图，要求从顶点0出发经过所有点一次然后回到0点的一条权值之和最小的一条路的权值 #include #include #include #include #include #include #include #include #include #include #define INF 100000000 using namespace std; struc
【XSY1285】【BZOJ3814】【清华集训2014】简单回路 状压DP
ez_yww的博客
10-03 642
题目描述　　给你一个n×mn\times m的网格图和kk个障碍，有qq个询问，每次问你有多少个不同的不经过任何一个障碍点且经过(x,y)(x,y)与(x+1,y)(x+1,y)之间的简单回路　　n≤1000,m≤6,q≤10000n\leq 1000,m\leq 6,q\leq 10000题解　　先用状压DP求出前面ii行的状态和后面ii行的状态，询问时暴力合并。　　其实状态数很少的（不到2002
POJ3254：Corn Fields（状压dp入门）
weixin_34176694的博客
01-30 92
Corn Fields Time Limit:2000MS Memory Limit:65536K Total Submissions:14098 Accepted:7396 Description Farmer John has purchased a lush new rectangular pas...
最短Hamilton路径（二进制状态压缩dp）
A_Thinking_Reed_的博客
08-13 1493
题目描述 给定一张 n(n≤20) 个点的带权无向图，点从 0~n-1 标号，求起点 0 到终点 n-1 的最短Hamilton路径。 Hamilton路径的定义是从 0 到 n-1 不重不漏地经过每个点恰好一次。 输入 第一行一个整数n。 接下来n行每行n个整数，其中第i行第j个整数表示点i到j的距离（一个不超过10^7的正整数，记为a[i,j]）。 对于任意的x,y,z，数据保证 a[x...
CodeForces 21D Traveling Graph 状压dp+欧拉回路
九野的博客
07-01 1673
题目链接：点击打开链接 题意： 给定n个点m条边的无向图 求从1点开始经过每条边至少一次最后回到1点的最小路程 显然就是找一条路径可重复的欧拉回路 思路： 首先对于欧拉回路的结论是：所有点的度数都为偶数 因为所有边至少经过一次，那么可以把题意转换成加最少多少条边使得图满足以上结论 而加的边目的是为了把奇度数转成偶度数，先floyd一下得到任意点间加边的最小花费 dp[i]表示状态
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值