hdu 4771 - Stealing Harry Potter's Precious

题目：

Stealing Harry Potter's Precious

杭州赛区赛题重现时遇到的这题，比赛的时候T了，之后通过他人提醒重写的这题

题意：一个N*M的图，"#"是不能进也不能通过的房间，"."能通过，现在有K个宝藏放在这些房间里，"@"为起点，求从起点到收集完所有宝藏需要走几步，如果不能，输出-1

思路：

这题明显的搜索，可是怎么搜索，决定了成败。

比赛的时候我是先bfs预处理，用bvis记录能到达的地方，bvis[i][j]=1表示能到达，那么如果宝藏的地方为1，说明宝藏能到达，只要有一处为0就可以直接输出-1了

然后dfs，很浪的dfs:二维dfs，vis[k][i][j]表示在第k层的(i,j)的状态，每层遇到一个宝藏之后就转移到下一层。

当然，这样华丽滴T了。。。因为dfs的复杂度到达了O((n^2)^K),不T才怪..........亏我当初真敢写。。。

下面介绍AC的代码，而且是0ms AC：

同样是dfs+bfs，同样是bfs预处理，但是这次，我们引入一个图gg，gg[i][j]表示宝藏i到宝藏j的最短步数，gg[0][i]表示起点到宝藏i的最短步数

如何构建这个图？首先从起点开始bfs，搜出从起点到每一个宝藏的最短步数，更新gg，是否可达也是在这第一次bfs里判断的：搞一个cnt，每找到一个宝藏就+1，如果最后小于K的话就输出-1。

然后对每一个宝藏，从它开始bfs，计算它到每一个宝藏的最短步数，更新gg

最后对gg进行dfs

复杂度：bfs的复杂度为O(K * n^2) , dfs O(K^2) 而K最多才4.

当然这道题有点漏洞：比如多个宝藏处于同一个地点就会输出-1等

不管怎么样............代码如下：

#pragma comment(linker, "/STACK:102400000,102400000")
#include "iostream"
#include "cstring"
#include "algorithm"
#include "cmath"
#include "cstdio"
#include "sstream"
#include "queue"
#include "vector"
#include "string"
#include "stack"
#include "cstdlib"
#include "deque"
#include "fstream"
#include "map"
#define eps 1e-14
using namespace std;
typedef long long LL;
const int MAXN = 1000000+100;
const int INF = 0x6fffffff;
const int inf = 522133279;
const long long LLinf = 1e30;

int N,M;
int K;
char G[110][110];
int gg[10][10];
int vis[110][110];
int dvis[10];
int ok;
int dir[4][2] = {0,1,1,0,-1,0,0,-1};

struct node
{
    int id;
    int x;
    int y;
    int w;
}s;

vector<node> baozang;

int border(int x,int y)
{
    return (x >= 1 && x <= N) && (y >= 1 && y <= M);
}

void bfs(node src)
{
    queue<node> que;
    que.push(src);
    node pre,tmp;
    int cnt=0;

    while(!que.empty())
    {
        pre = que.front();
        que.pop();

        for(int i = 0 ; i < 4 ; i++)
        {
            int x = pre.x + dir[i][0];
            int y = pre.y + dir[i][1];

            if(border(x,y) && !vis[x][y] && G[x][y] != '#')
            {
                vis[x][y]=1;
                tmp.x = x , tmp.y = y , tmp.w = pre.w+1;
                que.push(tmp);

                if(G[x][y] == 'B')
                {
                    cnt++;
                    int pos=0;
                    for( ; pos < K ; pos++)
                        if(baozang[pos].x ==x && baozang[pos].y == y)
                            break;

                    gg[src.id][pos+1] = gg[pos+1][src.id] = min(gg[src.id][pos+1] , tmp.w);
                }
            }
        }
    }

    if(cnt < K)
        ok=0;
}

int minc;

void dfs(int pre , int cur , int cnt)
{
    if(cnt == K)
    {
        minc = min(minc , cur);
        return;
    }

    for(int i = 1 ; i <= K ; i++)
        if(!dvis[i])
        {
            dvis[i] = 1;
            dfs(i , cur + gg[pre][i] , cnt+1);
            dvis[i] = 0;
        }
}


int main()
{
    while(~scanf("%d%d" , &N,&M) && (N||M))
    {
        ok=1;
        minc = inf;
        memset(vis,0,sizeof(vis));
        memset(G,0,sizeof(G));
        memset(gg,0x1f,sizeof(gg));
        memset(dvis,0,sizeof(dvis));
        baozang.clear();

        getchar();

        for(int i = 1 ; i<= N ; i++)
        {
            for(int j = 1 ; j <= M ; j++)
            {
                G[i][j] = getchar();
                if(G[i][j] == '@')
                    s.id = 0 , s.x = i , s.y = j , s.w=0,vis[i][j]=1;
            }
            getchar();
        }

        scanf("%d" , &K);

        for(int i = 0 ; i < K ; i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);

            G[a][b]='B';
            node t;
            t.id = i+1 , t.x = a , t.y = b , t.w =0;
            baozang.push_back(t);
        }

        bfs(s);

        if(!ok)
            printf("-1\n");
        else
        {
            for(int i = 0 ; i < K ; i++)
            {
                memset(vis,0,sizeof(vis));
                vis[baozang[i].x][baozang[i].y]=1;
                bfs(baozang[i]);
            }
            dfs(0,0,0);
            printf("%d\n",minc);
        }
    }

    return 0;
}