hdu 3681(bfs+二分+状压dp判断)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3681

思路：机器人从出发点出发要求走过所有的Y，因为点很少，所以就能想到经典的TSP问题。首先bfs预处理出‘Y',’F','G'之间的最短距离，由于G点可以充电，到达G点就把当前能量更新为电池容量然后继续走。因为每个G点只能充一次电，这就好像TSP中的每个点只能走一次一样，然后就是二分答案了，用状压DP判定当前电池容量的情况下是否能符合条件。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

struct Node{
    int x,y;
}node[17*17];

int dist[17][17][17][17];
int dp[1<<17][17];
int n,m,state,final_state,start;
char map[17][17];
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};

void bfs(Node &node)
{
    queue<pair<int,int> >que;
    que.push(make_pair(node.x,node.y));
    dist[node.x][node.y][node.x][node.y]=0;
    while(!que.empty()){
        int x=que.front().first,y=que.front().second;
        que.pop();
        for(int i=0;i<4;i++){
            int xx=x+dir[i][0],yy=y+dir[i][1];
            if(xx>=0&&xx<n&&yy>=0&&yy<m&&map[xx][yy]!='D'){
                if(dist[node.x][node.y][xx][yy]==-1){
                    dist[node.x][node.y][xx][yy]=dist[node.x][node.y][x][y]+1;
                    que.push(make_pair(xx,yy));
                }
            }
        }
    }
}


bool Judge(int Power)
{
    memset(dp,-1,sizeof(dp));
    dp[(1<<start)][start]=Power;
    int res=-1;
    for(int i=0;i<(1<<state);i++){
        for(int j=0;j<state;j++){
            if((i&(1<<j))==0)continue;
            if(dp[i][j]<0)continue;
            if(((i&final_state)&final_state)==final_state)res=max(res,dp[i][j]);
            for(int k=0;k<state;k++){
                if((i&(1<<k))||(j==k))continue;
                if(dist[node[j].x][node[j].y][node[k].x][node[k].y]<0)continue;
                if(dp[i][j]-dist[node[j].x][node[j].y][node[k].x][node[k].y]<0)continue;
                dp[i|(1<<k)][k]=max(dp[i|(1<<k)][k],dp[i][j]-dist[node[j].x][node[j].y][node[k].x][node[k].y]);
                if(map[node[k].x][node[k].y]=='G')dp[i|(1<<k)][k]=Power;
            }
        }
    }
    return res>=0;
}


int main()
{
    int low,high,mid,ans;
    while(~scanf("%d%d",&n,&m)){
        if(n==0&&m==0)break;
        state=0;
        final_state=0;
        for(int i=0;i<n;i++){
            scanf("%s",map[i]);
            for(int j=0;j<m;j++){
                if(map[i][j]=='F'){
                    start=state;
                    node[state].x=i,node[state].y=j;
                    final_state|=(1<<state);
                    state++;
                }else if(map[i][j]=='G'){
                    node[state].x=i,node[state++].y=j;
                }else if(map[i][j]=='Y'){
                    node[state].x=i,node[state].y=j;
                    final_state|=(1<<state);
                    state++;
                }
            }
        }
        memset(dist,-1,sizeof(dist));
        for(int i=0;i<state;i++){
            bfs(node[i]);
        }
        low=0,high=300,ans=-1;
        while(low<=high){
            mid=(low+high)>>1;
            if(Judge(mid)){
                ans=mid;
                high=mid-1;
            }else
                low=mid+1;
        }
        printf("%d
",ans);
    }
    return 0;
}