hdu 4771 Stealing Harry Potter'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 invisible robe, his wand and his owl. When Hogwarts school is in holiday, Harry Potter has to go back to uncle Vernon‘s home. But he can‘t bring his precious with him. As you know, uncle Vernon never allows
such magic things in his house. So Harry has to deposit his precious in the Gringotts Wizarding Bank which is owned by some goblins. The bank can be considered as a N × M grid consisting of N × M rooms. Each room has a coordinate. The coordinates of the upper-left
room is (1,1) , the down-right room is (N,M) and the room below the upper-left room is (2,1)..... A 3×4 bank grid is shown below:

  Some rooms are indestructible and some rooms are vulnerable. Goblins always care more about their own safety than their customers‘ properties, so they live in the indestructible rooms and put customers‘ properties in vulnerable rooms. Harry Potter‘s precious
are also put in some vulnerable rooms. Dudely wants to steal Harry‘s things this holiday. He gets the most advanced drilling machine from his father, uncle Vernon, and drills into the bank. But he can only pass though the vulnerable rooms. He can‘t access
the indestructible rooms. He starts from a certain vulnerable room, and then moves in four directions: north, east, south and west. Dudely knows where Harry‘s precious are. He wants to collect all Harry‘s precious by as less steps as possible. Moving from
one room to another adjacent room is called a ‘step‘. Dudely doesn‘t want to get out of the bank before he collects all Harry‘s things. Dudely is stupid.He pay you $1,000,000 to figure out at least how many steps he must take to get all Harry‘s precious.

Input

  There are several test cases.

  In each test cases:

  The first line are two integers N and M, meaning that the bank is a N × M grid(0<N,M <= 100).

  Then a N×M matrix follows. Each element is a letter standing for a room. ‘#‘ means a indestructible room, ‘.‘ means a vulnerable room, and the only ‘@‘ means the vulnerable room from which Dudely starts to move.

  The next line is an integer K ( 0 < K <= 4), indicating there are K Harry Potter‘s precious in the bank.

  In next K lines, each line describes the position of a Harry Potter‘s precious by two integers X and Y, meaning that there is a precious in room (X,Y).

  The input ends with N = 0 and M = 0

Output

  For each test case, print the minimum number of steps Dudely must take. If Dudely can‘t get all Harry‘s things, print -1.

Sample Input

2 3
##@
#.#
1
2 2
4 4
#@##
....
####
....
2
2 1
2 4
0 0

Sample Output

-1
5

思路:用一个三维数组记录拿到某些宝物后的状态,存储拿到某些宝物后的最短时间。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
#define N 105
#define M 30000
const int inf=(int)1e8;
char g[N][N];
int a[N][N];        //记录每个宝物的编号
int mark[N][N][32];
int k,n,m,l,ans;
int dir[4][2]={0,1,0,-1,-1,0,1,0};
struct node
{
    int x,y,s,t;  //状态和时间
    int num;    //宝物数量
    friend bool operator<(node a,node b)
    {
        return a.t>b.t;
    }
};
bool judge(int x,int y)
{
    if(x<0||x>=n||y<0||y>=m||g[x][y]=='#')
        return true;
    return false;
}
void inti()   //初始化数组,时间为无穷大
{
    int i,j,k;
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            for(k=0;k<l;k++)
            {
                mark[i][j][k]=inf;
            }
        }
    }
}
void bfs(int x,int y)
{
    int i,di,dj;
    priority_queue<node>q;
    node cur,next;
    cur.t=cur.s=cur.num=0;
    cur.x=x;
    cur.y=y;
    mark[x][y][0]=0;
    q.push(cur);
    while(!q.empty())
    {
        cur=q.top();
        q.pop();
        if(next.num==k)
        {
            ans=min(ans,next.t);
            continue;
        }
        for(i=0;i<4;i++)
        {
            next.x=di=cur.x+dir[i][0];
            next.y=dj=cur.y+dir[i][1];
            next.t=cur.t+1;
            next.s=cur.s;
            next.num=cur.num;
            if(judge(di,dj))
                continue;
            int t=a[di][dj];
            if(t!=-1&&(next.s&(1<<t))==0)
            {
                next.s|=(1<<t);
                next.num++;
                if(next.num==k)
                {
                    ans=min(ans,next.t);
                    return ;
                }
            }
            if(mark[di][dj][next.s]>next.t)
            {
                mark[di][dj][next.s]=next.t;
                q.push(next);
            }
        }
    }
}
int main()
{
    int i,j,x,y;
    int si,sj;
    while(scanf("%d%d",&n,&m),n||m)
    {
        for(i=0;i<n;i++)
        {
            scanf("%s",g[i]);
            for(j=0;j<m;j++)
            {
                if(g[i][j]=='@')
                {
                    si=i;sj=j;
                }
            }
        }
        scanf("%d",&k);
        memset(a,-1,sizeof(a));
        for(i=0,l=1;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            a[x-1][y-1]=i;
            l=l<<1;      //最多4个宝物,故状态的最大值为1111,
        }                //l为总的状态数加一
        inti();
        ans=inf;
        bfs(si,sj);
        if(ans==inf)
            ans=-1;
        printf("%d\n",ans);
    }
    return 0;
}

hdu 4771 Stealing Harry Potter's Precious (状态压缩+bfs)

时间: 2024-10-13 00:48:33

hdu 4771 Stealing Harry Potter's Precious (状态压缩+bfs)的相关文章

【HDU 4771 Stealing Harry Potter&#39;s Precious】BFS+状压

2013杭州区域赛现场赛二水... 类似“胜利大逃亡”的搜索问题,有若干个宝藏分布在不同位置,问从起点遍历过所有k个宝藏的最短时间. 思路就是,从起点出发,搜索到最近的一个宝藏,然后以这个位置为起点,搜索下一个最近的宝藏,直至找到全部k个宝藏.有点贪心的感觉. 由于求最短时间,BFS更快捷,但耗内存,这道题就卡在这里了... 这里记录了我几次剪枝的历史...题目要求内存上限32768KB,就差最后600KB了...但我从理论上觉得已经不能再剪了,留下的结点都是盲目式搜索必然要访问的结点. 在此贴

HDU 4771 Stealing Harry Potter&#39;s Precious (深搜+广搜)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4771 题面: 欢迎参加--BestCoder周年纪念赛(高质量题目+多重奖励) Stealing Harry Potter's Precious Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2207    Accepted Submis

HDU 4771 Stealing Harry Potter&#39;s Precious

http://acm.hdu.edu.cn/showproblem.php?pid=4771 题意: 给定一副NxM的地图, '#'不可走, '.'可走, '@'为起点 再给出K个(0<K<=4)宝藏点 问从起点开始,走过所有宝藏点的最小步数 若有宝藏点不能到达则输出-1 解法: bfs(最小步数) + dfs(顺序) bfs预处理,先从起点开始,若有点无法到达直接输出-1 再枚举宝藏点作为起点求出每两点间的最小步数,存入数组中(step[i][j]表示从i点到j点的最小步数) 最后dfs枚举

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

题意: n*m的迷宫,有一些格能走(“.”),有一些格不能走(“#”).起始点为“@”. 有K个物体.(K<=4),每个物体都是放在“.”上. 问最少花多少步可以取完所有物体. 思路: BFS+状压,看代码. 代码: struct node{ int x,s; node(int _x,int _s){ x=_x, s=_s; } }; int n,m,k,sx,sy; char graph[105][105]; int px[5],py[5]; int dp[105][105][35]; int

HDU 4771 Stealing Harry Potter&#39;s Precious dfs+bfs

Stealing Harry Potter's Precious Problem Description Harry Potter has some precious. For example, his invisible robe, his wand and his owl. When Hogwarts school is in holiday, Harry Potter has to go back to uncle Vernon's home. But he can't bring his

Hdu 4771 Stealing Harry Potter&#39;s Precious (搜索)

题目大意: 地图上有最多4件物品,小偷要全部拿走,问最少的路程. 思路分析: 考虑到物品数量只有4. 可以先用最多5次bfs求出每个目标点到其他目标点的距离. 然后枚举依次拿取物品的顺序,用next_permutation... #include <cstdio> #include <iostream> #include <cstring> #include <algorithm> #include <queue> using namespace

hdu 4771 Stealing Harry Potter&#39;s Precious (2013亚洲区杭州现场赛)(搜索 bfs + dfs) 带权值的路径

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4771 题目意思:'@'  表示的是起点,'#' 表示的是障碍物不能通过,'.'  表示的是路能通过的: 目的:让你从 '@' 点出发,然后每个点只能走一次,求出最小的距离: 解题思路:先用 bfs 求解出任意两点之间的距离,用 ans[i][j],表示点 i 到点  j 的距离: 然后用 dfs 递归求出从起点经过所有点的距离中,比较出最小的: AC代码: 1 #include<iostream>

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): 1982    Accepted Submission(s): 931 Problem Description Harry Potter has some precious. For example, his invisib

hdu 4771 Stealing Harry Potter&#39;s Precious(bfs)

题目链接:hdu 4771 Stealing Harry Potter's Precious 题目大意:在一个N*M的银行里,贼的位置在'@',现在给出n个宝物的位置,现在贼要将所有的宝物拿到手,问最短的路径,不需要考虑离开. 解题思路:因为宝物最多才4个,加上贼的位置,枚举两两位置,用bfs求两点距离,如果存在两点间不能到达,那么肯定是不能取完所有的宝物.然后枚举取宝物的顺序,维护ans最小. #include <cstdio> #include <cstring> #inclu