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[*];

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

 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]=;
     while(!que.empty()){
         int x=que.front().first,y=que.front().second;
         que.pop();
         for(int i=;i<;i++){
             int xx=x+dir[i][],yy=y+dir[i][];
             if(xx>=&&xx<n&&yy>=&&yy<m&&map[xx][yy]!='D'){
                 if(dist[node.x][node.y][xx][yy]==-){
                     dist[node.x][node.y][xx][yy]=dist[node.x][node.y][x][y]+;
                     que.push(make_pair(xx,yy));
                 }
             }
         }
     }
 }

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

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