hdu 3681 Prison Break (状态压缩dp/dfs + bfs)

最新推荐文章于 2021-12-24 14:04:14 发布
最新推荐文章于 2021-12-24 14:04:14 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： dp 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012841845/article/details/18950575
版权
dp 同时被 2 个专栏收录
59 篇文章 0 订阅
订阅专栏
搜索
30 篇文章 0 订阅
订阅专栏

题意：一幅矩阵迷宫，給起点，开始时充满电，要求是遍历给定的点，每移动一次花费1，

迷宫中有若干充电池可充满电（每个充电池只能用一次），求原始电量最少是多少。


分析：

1、由于所有'Y'处一定要走到，‘G'可以走也可以不走，且他们的总个数最多只有15个。

the sum of energy pools and power switches is less than 15.

因此可以用状态压缩思想记录最终的状态。

因此要给这些符号所在的位置编号。 用hash思想把图中各符号的位置用横纵坐标唯一表示。

即posid=x*列数+y。

2、重新建图，把能走的点之间建边，然后bfs出图中任意两个点之间的最短距离。

3、二分枚举原始电量，找到最小值。

验证能否达到末态的过程中，如果要走的点为'G'，则电量为原始的满电量，否则为这一步的起点

位置电量 - 起点到终点的最短距离。


bfs+dfs

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>

using namespace std;

struct edge
{
    int to,next;
}e[2000];

struct node
{
    int vid,step;
};

char mp[20][20];
int id[20][20],c[20][2],head[300],dis[20][20];
int cnt,obj,ids,mid,m,n;
bool mk[20];

void init()
{
    memset(id,-1,sizeof(id));
    memset(dis,-1,sizeof(dis));
    memset(head,-1,sizeof(head));
    cnt=0;ids=1;obj=0;
}

void add(int x,int y)
{
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt++;
}

void bfs(int x)
{
    int u,v;
    node djw,cur,next;
    queue<node> q;
    bool vis[400];
    memset(vis,0,sizeof(vis));

    djw.vid=x;
    djw.step=0;
    q.push(djw);
    vis[x]=true;
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        u=cur.vid;
        if(id[u/m][u%m]!=-1)
            dis[id[x/m][x%m]][id[u/m][u%m]]=cur.step;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            v=e[i].to;
            if(!vis[v])
            {
                vis[v]=true;
                next.vid=v;
                next.step=cur.step+1;
                q.push(next);
            }
        }
    }
}

int dfs(int bag,int pos,int sta)
{
    if((sta&obj)==obj) return 1;
    for(int i=0;i<ids;i++)
    {
        if(mk[i] || dis[pos][i]==-1) continue;
        if(dis[pos][i]<=bag)
        {
            if(mp[c[i][0]][c[i][1]]=='G')
            {
                mk[i]=true;
                if(dfs(mid,i,sta|(1<<i))) return 1;
                mk[i]=false;
            }
            else
            {
                mk[i]=true;
                if(dfs(bag-dis[pos][i],i,sta|(1<<i))) return 1;
                mk[i]=false;
            }
        }
    }
    return 0;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0 && m==0)
            break;
        init();
        for(int i=0;i<n;i++)
            scanf("%s",mp[i]);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(mp[i][j]=='D') continue;
                if(mp[i][j]=='F')
                {
                    c[0][0]=i;
                    c[0][1]=j;
                    id[i][j]=0;
                }
                else if(mp[i][j]=='G')
                {
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                }
                else if(mp[i][j]=='Y')
                {
                    c[ids][0]=i;
                    c[ids][1]=j;
                    obj|=(1<<ids);
                    id[i][j]=ids++;
                }
                if(i-1>=0 && mp[i-1][j]!='D')
                    add(i*m+j,(i-1)*m+j);
                if(i+1<n && mp[i+1][j]!='D')
                    add(i*m+j,(i+1)*m+j);
                if(j-1>=0 && mp[i][j-1]!='D')
                    add(i*m+j,i*m+j-1);
                if(j+1<m && mp[i][j+1]!='D')
                    add(i*m+j,i*m+j+1);
            }
        }
        for(int i=0;i<ids;i++)
            bfs(c[i][0]*m+c[i][1]);
        int flag=1;
        for(int i=1;i<ids;i++)
        {
            if(mp[c[i][0]][c[i][1]]=='Y' && 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(mk,0,sizeof(mk));
                mk[0]=true;
                if(dfs(mid,0,1))
                {
                    ans=mid;
                    r=mid-1;
                }
                else
                    l=mid+1;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}


dp+bfs

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>

using namespace std;

struct edge
{
    int to,next;
}e[2000];

struct node
{
    int vid,step;
};

char mp[20][20];
int id[20][20],c[20][2],head[300],dis[20][20];
int dp[1<<16][16];
int cnt,obj,ids,mid,m,n;

void init()
{
    memset(id,-1,sizeof(id));
    memset(dis,-1,sizeof(dis));
    memset(head,-1,sizeof(head));
    cnt=0;ids=1;obj=0;
}

void add(int x,int y)
{
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt++;
}

void bfs(int x)
{
    int u,v;
    node djw,cur,next;
    queue<node> q;
    bool vis[400];
    memset(vis,0,sizeof(vis));

    djw.vid=x;
    djw.step=0;
    q.push(djw);
    vis[x]=true;
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        u=cur.vid;
        if(id[u/m][u%m]!=-1)
            dis[id[x/m][x%m]][id[u/m][u%m]]=cur.step;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            v=e[i].to;
            if(!vis[v])
            {
                vis[v]=true;
                next.vid=v;
                next.step=cur.step+1;
                q.push(next);
            }
        }
    }
}

int solve(int mid)
{
    memset(dp,-1,sizeof(dp));
    dp[1][0]=mid;
    for(int i=0;i<(1<<ids);i++)
    {
        for(int j=0;j<ids;j++)
        {
            if((i&(1<<j)==0) || dp[i][j]==-1) continue;
            if((i&obj)==obj) return 1;
            for(int k=0;k<ids;k++)
            {
                if(j==k || i&(1<<k)) continue;
                if(dis[j][k]==-1) continue;
                if(dp[i][j]>=dis[j][k])
                {
                    if(dp[i|(1<<k)][k]==-1 || dp[i|(1<<k)][k]<dp[i][j]-dis[j][k])
                        dp[i|(1<<k)][k]=dp[i][j]-dis[j][k];
                    if(mp[c[k][0]][c[k][1]]=='G')
                        dp[i|(1<<k)][k]=mid;
                }
            }
        }
    }
    return 0;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0 && m==0)
            break;
        init();
        for(int i=0;i<n;i++)
            scanf("%s",mp[i]);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(mp[i][j]=='D') continue;
                if(mp[i][j]=='F')
                {
                    c[0][0]=i;
                    c[0][1]=j;
                    id[i][j]=0;
                }
                else if(mp[i][j]=='G')
                {
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                }
                else if(mp[i][j]=='Y')
                {
                    c[ids][0]=i;
                    c[ids][1]=j;
                    id[i][j]=ids++;
                    obj|=(1<<(ids-1));
                }
                if(i-1>=0 && mp[i-1][j]!='D')
                    add(i*m+j,(i-1)*m+j);
                if(i+1<n && mp[i+1][j]!='D')
                    add(i*m+j,(i+1)*m+j);
                if(j-1>=0 && mp[i][j-1]!='D')
                    add(i*m+j,i*m+j-1);
                if(j+1<m && mp[i][j+1]!='D')
                    add(i*m+j,i*m+j+1);
            }
        }
        for(int i=0;i<ids;i++)
            bfs(c[i][0]*m+c[i][1]);
        int ans=-1;
        int l=0,r=n*m*(ids-1);
        while(l<=r)
        {
            mid=(l+r)>>1;
            if(solve(mid))
            {
                ans=mid;
                r=mid-1;
            }
            else
                l=mid+1;
        }
        printf("%d\n",ans);
    }
    return 0;
}


hadis_fukan
关注
专栏目录
C++万能头文件 bits/stdc++.h 的用法和优缺点 包含哪些文件头
06-20 3481
它是C++中支持的一个几乎万能的头文件，几乎包含所有的可用到的C++库函数。以后写代码就可以直接引用这一个头文件了，不需要在写一大堆vector、string、map、stack……int main() { // write code here}#if __cplusplus >= 201103L #include #include #include #include #include ...
C++中万能头文件bits/stdc++.h的介绍
QAQ的博客
05-28 6万+
很多小伙伴估计看有的代码会碰见没有多余的其它头文件比如algorithm、cmath、iostream而是用了一行#include&lt;bits/stdc++.h&gt;这样的头文件并感到诧异，想这是什么。其实这是一个包含了C++所有头文件的一个头文件，为了方便而发明的，其中包含了一下头文件//c #ifndef _GLIBCXX_NO_ASSERT #include&lt;cassert&gt...
POJ1252 完全背包 dp 搜索 dfs bfs
671coder的专栏
01-20 4511
今天见到一道不错的水题，但是卡了我两次，是道完全背包，也可以用搜索，因为刚刚开始练习背包，可谓入门，感觉这是道不错的题，就用dp小试一下。 连接：http://poj.org/problem?id=1252 题目大意：给6种不同面额硬币，求组成[1,100]中数的平均需要硬币与最多需要硬币数，可以通过减法获得，比如有1、4两种硬币，凑成3可以用4-1两个硬币完成，而不是1+1+1三个硬
hdu3681之状态压缩dp
Stephen
04-01 1965
Prison Break Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2845    Accepted Submission(s): 710 Problem Description Rompire is a r
HDU 3681 Prison Break（状态压缩DP+BFS+二分答案）
weixin_34095889的博客
04-25 132
Prison Break Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 2178    Accepted Submission(s): 533 Problem Description Rompire is a robot kingd...
hdu 3681
XYM-AC之路
08-26 2187
题意：一个机器人想越狱，他只能带一定电量的电池，'S'表示道路可行，'G'表示充电器，只可充电一次，但是可以经过很多次。'F'表示起点，'Y'表示要破坏的机关，也是只能破坏一次，但是可以经过无数次。'D'表示不能经过的地点。求他能破坏所有机关，带的最小初始电量。 虽然知道要用d
HDU - 3681(bfs+状压dp+二分)
weixin_43958964的博客
03-30 224
题目：click 题意：给定一个n*m的地图，D表示不能走的地方，G补充满能量，问从F点走完所有的Y点最小的能量，走一个消耗一格能量。 注意一下题目中所给的范围，Y+G的数量不超过15。在无数条路径中找出一条最佳路径，D是不能走的，所需点的数量顶多16个(加上了F点)，其实可以发现本质就是一个TSP的变形问题，所需要的点也就这三个。bfs处理出每两个点的最短距离，建立一个新的图。 之后直接状压dp...
vc2019中 源文件<bits/stdc++.h>无法打开
最新发布
05-19
在VC2019中，当你遇到"源文件<bits/stdc++.h>无法打开"的问题时，这通常意味着你试图在你的C++项目中使用一个预编译头文件，但是这个文件在标准库中并不存在。`<bits/stdc++.h>`是GCC编译器中的一个非标准头文件，它...
【C++】万能头文件 ＜bits/stdc++.h＞ 的用法和优缺点
热门推荐
Sunnyside_
06-24 18万+
【C++】万能头文件 bits/stdc++.h 的用法和优缺点 文章目录【C++】万能头文件 bits/stdc++.h 的用法和优缺点一、使用方法二、头文件的内容三、VS 中如何使用四、优点与缺点   最近在参考别人的代码时，发现了这么一个头文件，在C++中引用很广泛。然后查了以下，总结一下。 #include <bits/stdc++.h>   它是C++中支持的一个几乎万能的头文件，几乎包含所有的可用到的C++库函数。以后写代码就可以直接引用这一个头文件了，不需要在写一大堆vecto
状态压缩(1)--hdu5094(状态压缩+bfs)(能力题）
Sly_461的博客
09-09 929
Maze Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 100000/100000 K (Java/Others) Problem Description This story happened on
HDU - 3681 Prison Break（状态压缩 + 最短路）
静静地码
08-01 918
题目大意：有一个机器人想越狱，越狱的要求是将所有的电网开关关掉。现在给出一个地图，’S’表示空地，‘F‘表示起始地点，‘G‘表示充电池，‘D‘表示禁地，‘Y‘开关 充电池可以将机器人的电充满。机器人每走一格就需要耗掉1点能量，问机器人的起始能量至少要是多少才可以逃出监狱解题思路：先将所有能连通的点连通起来，将充电池和开关抽象出来，压缩成一个状态 求出每个充电池和开关之间的两两间的最短距离，接着二
HDU 3681-Prison Break（状压DP+二分+BFS）
信仰.的博客
08-08 499
Prison Break Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 5110    Accepted Submission(s): 1406 Problem Description Rompire is a robo
HDU3681Prison Break(状态压缩+BFS)
青山绿水之辈 专栏
09-02 1248
Prison Break Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3165    Accepted Submission(s): 804 Problem Description Rompire is a robot
HDU-3681 Prison Break (bfs + 二分枚举)
m0_37711725的博客
07-29 298
题目大意:要求主角打开所有开关从而能打开监狱从而逃走。 要求：主角梅走一步都会消耗一单位的能量，不能通过'D'，‘G’是补充能量的地方（意味着在此处主角可将能量补到电池容量大小），可以补满能量，‘Y’是开关，主角刚开始能量也是满的，问主角想要逃走电池容量至少得有多少。 思路：会随着主角移动而改变的物件有：能量包，开关。 状态压缩能量包和开关的状态，从小往大枚举最大电容量，看rob
hdu 3681 Prison Break
Kona的博客
10-31 330
  题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3681 题意：n*m矩阵有加起来不超过十五个的G和Y，你需要走过所有的Y，移动一次需要一电量，问最少需要多大的电池。 思路：如果没有G，就是一个很简单的最短路了，有了G就很复杂，我们二分讨论V，用状压dp做辅助，dp[S][k] = max(dp[S+{j}][j] - dis[j][k]) ...
C++ 路径问题汇总 涉及DP, DFS, BFS和回溯
406156440的博客
08-22 2988
最近这几天忙着参加各大互联网公司的笔试, 发现有一个规律, 算法题都喜欢出路径问题, 二维数组作为地图, 从(0,0)点到(m-1,n-1)点最短花费, 至少删除多少个障碍才能够到达等等, 总之就是二维数组找路径, 其中有不同的障碍物, 不同的分值, 总之八仙过海各显神通, 可能是因为涉及到很多的知识, 因此大家都乐意出这样的题吧; 今天小弟在这里献上收集来的各种题型和解题思路 1. 广度优先搜索和优先队列配合 不同道路不同消费并且含有障碍物, 问从(0,0)到(m-1, n-1)的最低消费, 注意:
网络延时 DFS BFS DP
weixin_45448563的博客
02-21 234
网络延时 DFS BFS DP DP 思路: dfs 作用：返回以该点为根，到叶子节点的最大长度加1 即加上该顶点上面一条边 , 由递推公式:dfs(i)=max{dfs(j)}+1 dfs(叶子节点)=1 #include<iostream> using namespace std; #include<cstring> int idx; int e[20005]; int h[20005]; int ne[20005]; int ans; int n,m; void ad
力扣精选题——单词拆分（dp+dfs+dfs(备忘录)+bfs+bfs(备忘录)）
wys74230859的博客
12-24 428
一道题通过动态规划，深搜，深搜+备忘录，广搜，广搜+备忘录五种方法来分析
7月17号：完全背包问题例题，322. 零钱兑换：DP，DFS，BFS
weixin_40857308的博客
07-17 204
今天的每日一练很没意思，就不说了 主要是来复习一遍昨天的 322. 零钱兑换 用dfs和bfs来解决： 首先是非递归的bfs: class Solution: def coinChange(self, coins: List[int], amount: int) -> int: #简单bfs if amo...
树形DP与状态压缩DP讲解-陈益波
接下来，陈博士通过一个例题——HDU2412 PARTYATHALI-BULA，讲解了状态压缩DP的具体应用。这道题目涉及一个组织的人员关系树，目标是找出能够被选入团队而不产生上下级关系的人的最大数量。他指出，简单的染色统计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值