HDU3681Prison Break（BFS+TSP+二分+dp状态压缩）

题意： n*m的图上，机器人要从F出发关闭所有的Y。同时，G是可以充电的，但是只能充一次电，机器人每走一步消耗一个单位的电，问机器人需要带的最小的电池容量是多少。
解法：看了网上的题解，是TSP问题的变形， TSP是旅行商问题，即有n个城市，两两之间均有道路相连，给出每两个城市i，j之间的道路长度Lij，求经过每个城市一次仅且一次，最后回到起点，使得经过的道路长度最短，n<=15(一般是TSP问题的标志)。
设dp(s,i):表示当前在城市i，访问S中的城市一遍后回到出发点的最短路，那么有dp(S,i)=min(dp(S-{j} ,j ) +dist(j, i) ) j是属于集合S。
时间复杂度是O(n^2*2^n)
本题也是每个点Y,G,F,只走一次，需要先用BFS处理Y，F，G任意之间的距离，相当于建立一个新图，然后二分时用dp判断是否可以

本题dp[s][i]:表示经过状态 S 到达 i 电池的最大剩余电量，状态S就是，i已经访问的点集（包括i）。
dp[s][i]=min(dp[s-{j}][i]- dist[i][j]);

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
#include<set>
#include<stack>
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
#define out(x) cout<<x<<endl;
using namespace std;
const int maxn=16;
const int inf=9999999;
const int mod=100007;
int n,m;
char a[maxn][maxn];
int dis[maxn][maxn][maxn][maxn];
int dir[][2]={1,0,0,1,-1,0,0,-1};
int dp[1<<maxn][maxn];
struct node{
    int x,y;
    node(){}
    node(int _x,int _y):x(_x),y(_y){}
}p[maxn];///保存F,G,Y的坐标
int sum,start,aim;///sum是F,G,Y的个数，start是标记起点F在p数组的位置,aim是目标的状态压缩，即Y都要访问到
void bfs(node tmp){
    queue<node> q;
    q.push(tmp);
    dis[tmp.x][tmp.y][tmp.x][tmp.y]=0;
    while(!q.empty()){
        node x=q.front();q.pop();
        for(int i=0;i<4;i++){
            node s=x;
            s.x+=dir[i][0];
            s.y+=dir[i][1];
            if(s.x<0||s.x>=n||s.y<0||s.y>=m||a[s.x][s.y]=='D')continue;
            if(dis[tmp.x][tmp.y][s.x][s.y]!=-1)continue;
            dis[tmp.x][tmp.y][s.x][s.y]=dis[tmp.x][tmp.y][x.x][x.y]+1;
            q.push(s);
        }
    }
}

bool isok(int power){
    cl(dp,-1);
    int ans=-1;
    dp[1<<start][start]=power;///dp[0|=1<<start][start];
    for(int s=0;s<(1<<sum);s++){
        for(int i=0;i<sum;i++){
            if(!(s>>i&1))continue;//不包含i继续循环
            if(dp[s][i]<0)continue;//电量不够
            if((s&aim&aim)==aim)ans=max(ans,dp[s][i]);//到达目标，更新
            for(int j=0;j<sum;j++)if(i!=j){
                if(s>>j&1)continue;//把S中的J去掉
                if(dis[p[i].x][p[i].y][p[j].x][p[j].y]<0)continue;
                int xx=dp[s][i]-dis[p[i].x][p[i].y][p[j].x][p[j].y];
                if(xx<0)continue;
                dp[s|(1<<j)][j]=max(dp[s|(1<<j)][j],xx);//转移的时候，记得把j添加回去
                if(a[p[j].x][p[j].y]=='G')dp[s|(1<<j)][j]=power;
            }
        }
    }
    return ans>=0;
}




int main(){

    while(~scanf("%d%d",&n,&m)&&(n||m)){
        sum=0;aim=0;
        for(int i=0;i<n;i++){
            scanf("%s",a[i]);
            for(int j=0;j<m;j++){
                if(a[i][j]=='F'){
                    start=sum;
                    aim|=(1<<sum);
                    p[sum++]=node(i,j);
                }
                else if(a[i][j]=='Y'){
                    aim|=(1<<sum);
                    p[sum++]=node(i,j);
                }
                else if(a[i][j]=='G'){
                    p[sum++]=node(i,j);
                }
            }
        }
        cl(dis,-1);
        for(int i=0;i<sum;i++){
            bfs(p[i]);
        }

        int l=0,r=400,ans=-1;
        while(l<=r){
            int mid=(l+r)>>1;
            if(isok(mid)){
                ans=mid;
                r=mid-1;
            }
            else {
                l=mid+1;
            }
        }
        printf("%d\n",ans);

    }
    return 0;
}