hdu 1429(BFS+状态压缩)

胜利大逃亡(续)

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 7895    Accepted Submission(s): 2795

Problem Description

Ignatius再次被魔王抓走了(搞不懂他咋这么讨魔王喜欢)……


次魔王汲取了上次的教训,把Ignatius关在一个n*m的地牢里,并在地牢的某些地方安装了带锁的门,钥匙藏在地牢另外的某些地方。刚开始
Ignatius被关在(sx,sy)的位置,离开地牢的门在(ex,ey)的位置。Ignatius每分钟只能从一个坐标走到相邻四个坐标中的其中一
个。魔王每t分钟回地牢视察一次,若发现Ignatius不在原位置便把他拎回去。经过若干次的尝试,Ignatius已画出整个地牢的地图。现在请你帮
他计算能否再次成功逃亡。只要在魔王下次视察之前走到出口就算离开地牢,如果魔王回来的时候刚好走到出口或还未到出口都算逃亡失败。

Input

每组测试数据的第一行有三个整数n,m,t(2<=n,m<=20,t>0)。接下来的n行m列为地牢的地图,其中包括:

. 代表路
* 代表墙
@ 代表Ignatius的起始位置
^ 代表地牢的出口
A-J 代表带锁的门,对应的钥匙分别为a-j
a-j 代表钥匙,对应的门分别为A-J

每组测试数据之间有一个空行。

Output

针对每组测试数据,如果可以成功逃亡,请输出需要多少分钟才能离开,如果不能则输出-1。

Sample Input

4 5 17
@A.B.
a*.*.
*..*^
c..b*

4 5 16
@A.B.
a*.*.
*..*^
c..b*

Sample Output

16
-1

Author

LL

Source

ACM暑期集训队练习赛(三)

Recommend

将钥匙压缩,枚举所有状态。。一个小错误差点要了我老命

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <iostream>
using namespace std;
const int N = 22;
int n,m,t;
int vis[N][N][1<<10]; ///第三维存的钥匙的状态
char graph[N][N];
struct Node{
    int x,y,step,state;
}s;
int dir[][2] = {{-1,0},{1,0},{0,1},{0,-1}};
bool check(int x,int y){
    if(x<1||y<1||x>n||y>m||graph[x][y]==‘*‘) return false;
    return true;
}
int bfs(){
    memset(vis,false,sizeof(vis));
    queue<Node> q;
    q.push(s);
    vis[s.x][s.y][0] = 0;
    while(!q.empty()){
        Node now = q.front();
        q.pop();
        if(now.step>=t) return -1;
        if(graph[now.x][now.y]==‘^‘) return now.step;
        Node next;
        for(int i=0;i<4;i++){
            next.x = now.x+dir[i][0];
            next.y = now.y+dir[i][1];
            next.step = now.step+1;
            next.state = now.state;
            if(!check(next.x,next.y)||vis[next.x][next.y][next.state]) continue;
            char c = graph[next.x][next.y];
            if(isupper(c)){
                int t = c-‘A‘;
                if(!((1<<t)&next.state)) continue;
            }
            if(islower(c)){
                int t = c-‘a‘;
                next.state = (1<<t)|next.state;
            }
            if(!vis[next.x][next.y][next.state]){
                vis[next.x][next.y][next.state] = true;
                q.push(next);
            }
        }
    }
    return -1;  ///没加这句wa无数发....因为它有可能在前面两个出口都没出去..以后写程序一定要严谨点
}
int main(){
    while(scanf("%d%d%d",&n,&m,&t)!=EOF){
        for(int i=1;i<=n;i++){
            scanf("%s",graph[i]+1);
            for(int j=1;j<=m;j++){
                if(graph[i][j]==‘@‘){
                    graph[i][j]=‘.‘;
                    s.x = i;
                    s.y = j;
                    s.step = 0;
                    s.state = 0;
                }
            }
        }
        printf("%d\n",bfs());
    }
}
时间: 2024-08-07 06:12:46

hdu 1429(BFS+状态压缩)的相关文章

HDU 1429 (bfs+状态的位压缩)

hdu 1429 胜利大逃亡(续) 一共有10把钥匙,用10位的二进制反映钥匙的拥有情况 #include <iostream> #include <cstring> #include<cstdio> #include <queue> using namespace std; char maze[21][21]; int n,m,t; int dx[4]={0,1,0,-1}; int dy[4]={1,0,-1,0}; int vis[1024][21][

hdu 3502 bfs+状态压缩dp

题意是给你n*m的矩阵     每个单位有一个数,-1表示不能走   >=0表示有有多少个能量能获得    问从左上角到右下角能获得的做大能量值(走一步消耗1单位能量) 思路:  先bfs求出所有线之间的最短距离(当然  有用的只有有能量值的点和起点,终点) 然后状态压缩dp  找到最大能量值    这里有几个注意的地方 状态尽量从1开始    减少数组的空间(爆了一次)   其次是bfs是只搜有能量的点     其它都差不多: #include<stdio.h> #include<

HDU 1885 BFS+状态压缩

Key Task Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1239    Accepted Submission(s): 495 Problem Description The Czech Technical University is rather old - you already know that it celebrat

hdu 4856 Tunnels(bfs+状态压缩)

题目链接:hdu 4856 Tunnels 题目大意:给定一张图,图上有M个管道,管道给定入口和出口,单向,现在有人想要体验下这M个管道,问最短需要移动的距离,起点未定. 解题思路:首先用bfs处理出两两管道之间移动的距离,然后后用状态压缩求出最短代价,dp[i][j],i表示的已经走过的管道,j是当前所在的管道. #include <cstdio> #include <cstring> #include <queue> #include <algorithm&g

HDU 3247 Resource Archiver (AC自己主动机 + BFS + 状态压缩DP)

题目链接:Resource Archiver 解析:n个正常的串.m个病毒串,问包括全部正常串(可重叠)且不包括不论什么病毒串的字符串的最小长度为多少. AC自己主动机 + bfs + 状态压缩DP 用最短路预处理出状态的转移.能够优化非常多 AC代码: #include <cstdio> #include <iostream> #include <cstring> #include <algorithm> #include <queue> us

HDU 3247 Resource Archiver (AC自动机 + BFS + 状态压缩DP)

题目链接:Resource Archiver 解析:n个正常的串,m个病毒串,问包含所有正常串(可重叠)且不包含任何病毒串的字符串的最小长度为多少. AC自动机 + bfs + 状态压缩DP 用最短路预处理出状态的转移.可以优化很多 AC代码: #include <cstdio> #include <iostream> #include <cstring> #include <algorithm> #include <queue> using n

hdu 4568(状态压缩dp)

题意:一张n*m的网格内每个点有话费,还有若干个宝藏,问一个人要走进去拿走所有宝藏在走出来的最小花费. 思路:看宝藏只有13个直接想到了状压dp[i][j]拿了哪几个前一个为j的最小花费,先bfs+优先队列预处理出最短路,然后记忆化搜索就可. 代码如下: 1 /************************************************** 2 * Author : xiaohao Z 3 * Blog : http://www.cnblogs.com/shu-xiaohao

hdu--1429--胜利大逃亡(续) (bfs+状态压缩)

胜利大逃亡(续) Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 8560    Accepted Submission(s): 3071 Problem Description Ignatius再次被魔王抓走了(搞不懂他咋这么讨魔王喜欢)-- 这次魔王汲取了上次的教训,把Ignatius关在一个n*m的地牢里,并在地牢的某些地方安装了带

ACM/ICPC 之 BFS+状态压缩(POJ1324(ZOJ1361))

求一条蛇到(1,1)的最短路长,题目不简单,状态较多,需要考虑状态压缩,ZOJ的数据似乎比POj弱一些 POJ1324(ZOJ1361)-Holedox Moving 题意:一条已知初始状态的蛇,求其到(1,1)的最短路长 题解:开始做的时候用BFS暴力做了一次,结果RE了,后来看了其他的题解和discuss才转向状态压缩.也看到有人用A*做出来了. 现在简要介绍一下状态压缩的思路: 由于蛇身最长只有8,可以利用两条相邻蛇身坐标确定其相对方向(四个方向),两位二进制可以表示 这样 一个蛇头坐标+