hdu1885Key Task(状态压缩+bfs)

题目链接:

啊哈哈,点我点我

这题和hdu1429是姊妹题  请参见传送门

题目:

Key Task

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 1187    Accepted Submission(s): 470

Problem Description

The Czech Technical University is rather old — you already know that it celebrates 300 years of its existence in 2007. Some of the university buildings are old as well. And the navigation in old buildings can sometimes be a little bit tricky, because of strange
long corridors that fork and join at absolutely unexpected places.

The result is that some first-graders have often di?culties finding the right way to their classes. Therefore, the Student Union has developed a computer game to help the students to practice their orientation skills. The goal of the game is to find the way
out of a labyrinth. Your task is to write a verification software that solves this game.

The labyrinth is a 2-dimensional grid of squares, each square is either free or filled with a wall. Some of the free squares may contain doors or keys. There are four di?erent types of keys and doors: blue, yellow, red, and green. Each key can open only doors
of the same color.

You can move between adjacent free squares vertically or horizontally, diagonal movement is not allowed. You may not go across walls and you cannot leave the labyrinth area. If a square contains a door, you may go there only if you have stepped on a square
with an appropriate key before.

Input

The input consists of several maps. Each map begins with a line containing two integer numbers R and C (1 ≤ R, C ≤ 100) specifying the map size. Then there are R lines each containing C characters. Each character is one of the following:

Note that it is allowed to have

  • more than one exit,
  • no exit at all,
  • more doors and/or keys of the same color, and
  • keys without corresponding doors and vice versa.

    You may assume that the marker of your position (“*”) will appear exactly once in every map.

    There is one blank line after each map. The input is terminated by two zeros in place of the map size.

  • Output

    For each map, print one line containing the sentence “Escape possible in S steps.”, where S is the smallest possible number of step to reach any of the exits. If no exit can be reached, output the string “The poor student is trapped!” instead.

    One step is defined as a movement between two adjacent cells. Grabbing a key or unlocking a door does not count as a step.

    Sample Input

    1 10
    *........X
    
    1 3
    *#X
    
    3 20
    ####################
    #XY.gBr.*.Rb.G.GG.y#
    ####################
    
    0 0
    

    Sample Output

    Escape possible in 9 steps.
    The poor student is trapped!
    Escape possible in 45 steps.
    

    Source

    2008
    “Shun Yu Cup” Zhejiang Collegiate Programming Contest - Warm Up(2)

    Recommend

    linle   |   We have carefully selected several similar problems for you:  1882 1887 1889 1883 1888

    代码:

    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<queue>
    using namespace std;
    
    const int maxn=20+10;
    char map[maxn][maxn];
    int n,m,t;
    bool vis[maxn][maxn][(1<<10)+10];
    
    int dx[]={-1,1,0,0};
    int dy[]={0,0,-1,1};
    
    struct Point
    {
        int x,y,step;
        int key;
    };
    
    queue<Point>Q;
    Point st;
    
    bool check(int x,int y)
    {
        if(x>=1&&x<=n&&y>=1&&y<=m&&map[x][y]!='*')
             return true;
        return false;
    }
    
    int bfs()
    {
        while(!Q.empty())  Q.pop();
        memset(vis,false,sizeof(vis));
        vis[st.x][st.y][st.key]=true;
        st.key=st.step=0;
        Q.push(st);
        Point cur,nex;
        while(!Q.empty())
        {
            cur=Q.front();
            Q.pop();
            if(map[cur.x][cur.y]=='^')
                return cur.step;
            for(int i=0;i<4;i++)
            {
                nex.x=cur.x+dx[i];
                nex.y=cur.y+dy[i];
                nex.key=cur.key;
                if(check(nex.x,nex.y))
                {
                   nex.step=cur.step+1;
                   if(nex.step>=t)
                       continue;
                   else if(map[nex.x][nex.y]>='A'&&map[nex.x][nex.y]<='Z')
                   {
                      int temp=map[nex.x][nex.y]-'A';
                      int nk=cur.key&1<<temp;
                      if(nk&&!vis[nex.x][nex.y][nex.key])
                      {
                          vis[nex.x][nex.y][nex.key]=true;
                          Q.push(nex);
                      }
                   }
                   else if(map[nex.x][nex.y]>='a'&&map[nex.x][nex.y]<='z')
                   {
                       int temp=map[nex.x][nex.y]-'a';
                       nex.key=cur.key|1<<temp;
                       if(!vis[nex.x][nex.y][nex.key])
                       {
                           vis[nex.x][nex.y][nex.key]=true;
                           Q.push(nex);
                       }
                   }
                   else
                   {
                       if(!vis[nex.x][nex.y][nex.key])
                       {
                           vis[nex.x][nex.y][nex.key]=true;
                           Q.push(nex);
                       }
                   }
                }
             }
        }
        return -1;
    }
    
    inline void read_graph()
    {
        char str[maxn];
        for(int i=1;i<=n;i++)
        {
            scanf("%s",str+1);
            for(int j=1;j<=m;j++)
            {
                if(str[j]=='@')
                {
                    st.x=i;
                    st.y=j;
                    map[i][j]=str[j];
                }
                else  map[i][j]=str[j];
            }
        }
    }
    int main()
    {
        while(~scanf("%d%d%d",&n,&m,&t))
        {
            read_graph();
            int ans=bfs();
            printf("%d\n",ans);
        }
        return 0;
    }
    

    hdu1885Key Task(状态压缩+bfs)

    时间: 2024-11-06 09:42:15

    hdu1885Key Task(状态压缩+bfs)的相关文章

    HDU 1885 Key Task 状态压缩+搜索

    点击打开链接 Key Task Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1176    Accepted Submission(s): 462 Problem Description The Czech Technical University is rather old - you already know that it c

    hdu5094 状态压缩+bfs

    http://acm.hdu.edu.cn/showproblem.php?pid=5094 Problem Description This story happened on the background of Star Trek. Spock, the deputy captain of Starship Enterprise, fell into Klingon's trick and was held as prisoner on their mother planet Qo'noS.

    胜利大逃亡(续)(状态压缩bfs)

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

    2014 Super Training #6 G Trim the Nails --状态压缩+BFS

    原题: ZOJ 3675 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3675 由m<=20可知,可用一个二进制数表示指甲的状态,最多2^20,初始状态为0,表示指甲都没剪,然后BFS找解,每次枚举剪刀的两个方向,枚举移动的位数进行扩展状态即可. 代码: #include <iostream> #include <cstdio> #include <cstring> #include &

    hdu1429胜利大逃亡(续) (状态压缩+BFS)

    Problem Description Ignatius再次被魔王抓走了(搞不懂他咋这么讨魔王喜欢)-- 这次魔王汲取了上次的教训,把Ignatius关在一个n*m的地牢里,并在地牢的某些地方安装了带锁的门,钥匙藏在地牢另外的某些地方.刚开始Ignatius被关在(sx,sy)的位置,离开地牢的门在(ex,ey)的位置.Ignatius每分钟只能从一个坐标走到相邻四个坐标中的其中一个.魔王每t分钟回地牢视察一次,若发现Ignatius不在原位置便把他拎回去.经过若干次的尝试,Ignatius已画

    hdu 4771 Stealing Harry Potter&#39;s Precious (状态压缩+bfs)

    Stealing Harry Potter's Precious Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1297    Accepted Submission(s): 619 Problem Description Harry Potter has some precious. For example, his invisib

    hdu1429胜利大逃亡(续)(状态压缩+bfs)

    题目链接: 啊哈哈,点我点我 题意及思路 最开始我以为跟普通的bfs一样,所以直接写了一个朴素的bfs,一跑,前两组数据对了,但是第三组不对,一看,走过的还可以走啊,所以不能标记,结果我的bfs乱改,最后 毫无疑问改成了死循环.所以看题解... 思路:因为有10中不同的钥匙,每种都有两种状态,所以结合计算机是二进制保存的特点,刚好把这10把钥匙当成每一个为,要要1<<10个位保存所有的状态,然后就是模拟捡起钥匙,捡起钥匙就是说明这个位上的数字变成1这个状态,所以自然而然想到了位运算,只要|一下

    POJ 1324 Holedox Moving 贪吃蛇 状态压缩 BFS

    Description During winter, the most hungry and severe time, Holedox sleeps in its lair. When spring comes, Holedox wakes up, moves to the exit of its lair, comes out, and begins its new life. Holedox is a special snake, but its body is not very long.

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

    Problem Description Rompire is a robot kingdom and a lot of robots live there peacefully. But one day, the king of Rompire was captured by human beings. His thinking circuit was changed by human and thus became a tyrant. All those who are against him