hdu 4770 13 杭州 现场 A - Lights Against Dudely 暴力 bfs 状态压缩DP 难度:1

Description

Harry: "But Hagrid. How am I going to pay for all of this? I haven't any money." 
Hagrid: "Well there's your money, Harry! Gringotts, the wizard bank! Ain't no safer place. Not one. Except perhaps Hogwarts." 
― Rubeus Hagrid to Harry Potter. 
  Gringotts Wizarding Bank is the only bank of the wizarding world, and is owned and operated by goblins. It was created by a goblin called Gringott. Its main offices are located in the North Side of Diagon Alley in London, England. In addition to storing money and valuables for wizards and witches, one can go there to exchange Muggle money for wizarding money. The currency exchanged by Muggles is later returned to circulation in the Muggle world by goblins. According to Rubeus Hagrid, other than Hogwarts School of Witchcraft and Wizardry, Gringotts is the safest place in the wizarding world. 
  The text above is quoted from Harry Potter Wiki. But now Gringotts Wizarding Bank is not safe anymore. The stupid Dudley, Harry Potter's cousin, just robbed the bank. Of course, uncle Vernon, the drill seller, is behind the curtain because he has the most advanced drills in the world. Dudley drove an invisible and soundless drilling machine into the bank, and stole all Harry Potter's wizarding money and Muggle money. Dumbledore couldn't stand with it. He ordered to put some magic lights in the bank rooms to detect Dudley's drilling machine. 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. Dudely's machine can only pass the vulnerable rooms. So lights must be put to light up all vulnerable rooms. There are at most fifteen vulnerable rooms in the bank. You can at most put one light in one room. The light of the lights can penetrate the walls. If you put a light in room (x,y), it lights up three rooms: room (x,y), room (x-1,y) and room (x,y+1). Dumbledore has only one special light whose lighting direction can be turned by 0 degree,90 degrees, 180 degrees or 270 degrees. For example, if the special light is put in room (x,y) and its lighting direction is turned by 90 degrees, it will light up room (x,y), room (x,y+1 ) and room (x+1,y). Now please help Dumbledore to figure out at least how many lights he has to use to light up all vulnerable rooms. 
　　Please pay attention that you can't light up any indestructible rooms, because the goblins there hate light.

 

Input

　　There are several test cases. 
　　In each test case: 
　　The first line are two integers N and M, meaning that the bank is a N × M grid(0<N,M <= 200). 
　　Then a N×M matrix follows. Each element is a letter standing for a room. '#' means a indestructible room, and '.' means a vulnerable room. 
　　The input ends with N = 0 and M = 0 

 

Output

　　For each test case, print the minimum number of lights which Dumbledore needs to put. 
　　If there are no vulnerable rooms, print 0. 
　　If Dumbledore has no way to light up all vulnerable rooms, print -1.

 

Sample Input

2 2
##
##
2 3
#..
..#
3 3
###
#.#
###
0 0

 

Sample Output

0
2
-1

 

感想:这道题本来应该快速解决的

读题错误:0 只有15个需亮点 1 可以重复照明 2 可以照出区域

写错的地方: 1 ind数组没有清 2 k没有清 3 i 重定义

耗时的地方: 事先没有考虑清楚需要分别记录使用和不使用特殊灯的最小灯数

思路:因为只有15个需要照亮的地方,所以用2^15来记录状态,再用一个bool值记录特殊灯是否已经使用,然后DP即#include <cstdio>

#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int,int >P;
#define EMPTY(x,j) (~((x)&(1<<(j))))//是否编号为j的需照亮点未被照明
const int inf=0x7ffffff;
int n,m;
char maz[201][201];int ind[201][201],k;//maz 记录迷宫状态 ind 记录相应的需亮点序号 k 记录需亮点个数
int px[15],py[15];//记录需亮点坐标,x纵y横
int dis[128000][2];//记录达到状态i的最小灯数,dis[i][0]没有使用特殊灯 dis[i][1]使用了
bool vis[128000][2];//bfs判重节约空间时间
bool inmaze(int x,int y){
    return x>=0&&x<n&&y>=0&&y<m;
}
bool ok(int x,int y,int x2,int y2){//是否可以照
    if(inmaze(x,y)&&maz[x][y]=='#')return false;
    if(inmaze(x2,y2)&&maz[x2][y2]=='#')return false;
    return true;
}
const int dx[4][2]={{0,1},{1,0},{-1,0},{0,-1}};//特殊灯造成的 影响
const int dy[4][2]={{1,0},{0,-1},{0,1},{-1,0}};
int main(){
    while(scanf("%d%d",&n,&m)==2&&m){//输入
        k=0;
        memset(ind,0,sizeof(ind));
        for(int i=0;i<n;i++)scanf("%s",maz[i]);
        for(int i=0;i<n;i++)for(int j=0;j<m;j++){//统计需亮点
            if(maz[i][j]=='.'){
                px[k]=i;
                py[k]=j;
                ind[i][j]=k++;
            }
        }
        if(k==0){puts("0");continue;}//初始化
        fill(dis[0],dis[0]+(1<<(k+1)),inf);
        fill(vis[0],vis[0]+(1<<(k+1)),0);
        vis[0][0]=vis[0][1]=true;
        dis[0][0]=0;
        queue<P> que;
        que.push(P(0,false));
        while(!que.empty()){//bfs寻找
            int sta=que.front().first;int fl=que.front().second;que.pop();
            if(sta==(1<<k)-1)break;//全部都被照亮,因为每次步数为1,所以一定是最优解
            vis[sta][fl]=false;
            for(int i=0;i<k;i++){
                {
                    int sx=px[i],sy=py[i];
                    if(ok(sx-1,sy,sx,sy+1)){//在这个点放正常灯的影响状态
                        int tsta=sta|(1<<i);
                        if(inmaze(sx-1,sy))tsta|=(1<<ind[sx-1][sy]);
                        if(inmaze(sx,sy+1))tsta|=(1<<ind[sx][sy+1]);
                        if(dis[tsta][fl]>dis[sta][fl]+1){
                                dis[tsta][fl]=dis[sta][fl]+1;
                                if(!vis[tsta][fl]){
                                    vis[tsta][fl]=true;
                                    que.push(P(tsta,fl));
                                }
                        }
                    }
                    if(fl)continue;
                    for(int j=0;j<4;j++){//放特殊灯
                        int tx[2]={sx+dx[j][0],sx+dx[j][1]},ty[2]={sy+dy[j][0],sy+dy[j][1]};
                        if(ok(tx[0],ty[0],tx[1],ty[1])){//特殊灯可以有四个方向(其中有个方向没用)
                            int tsta=sta|(1<<i);
                            if(inmaze(tx[0],ty[0]))tsta|=(1<<ind[tx[0]][ty[0]]);
                            if(inmaze(tx[1],ty[1]))tsta|=(1<<ind[tx[1]][ty[1]]);
                            if(dis[tsta][1]>dis[sta][0]+1){
                                dis[tsta][1]=dis[sta][0]+1;
                                if(!vis[tsta][1]){
                                    vis[tsta][1]=true;
                                    que.push(P(tsta,1));
                                }
                            }
                        }
                    }
                }
            }
        }
        int ans=min(dis[(1<<k)-1][0],dis[(1<<k)-1][1]);
        printf("%d\n",ans==inf?-1:ans);
    }
    return 0;
}