hdu 3681 Prison Break

 

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

题意：n*m矩阵有加起来不超过十五个的G和Y，你需要走过所有的Y，移动一次需要一电量，问最少需要多大的电池。

思路：如果没有G，就是一个很简单的最短路了，有了G就很复杂，我们二分讨论V，用状压dp做辅助，dp[S][k] = max(dp[S+{j}][j] - dis[j][k]) 或者dp[S/{k}][k] = max(dp[S][j] - dis[j][k]) dp[S][k]代表集合S时到达j时的剩余电量，用结构体先存下所有的Y和G，就可以给他们编号形成了我们的集合S，dis是j到k的最短距离

 

#include
#include
#include
#include
#include
#define maxn 17
#define  inf 100000

using namespace std;

int n, m, sx, sy, cnt, goal, start;
char Map[maxn][maxn];
bool vis[maxn][maxn];
int dis[maxn][maxn][maxn];
int dp[1 << maxn][maxn];
int x[] = {1, 0, -1, 0};
int y[] = {0, 1, 0, -1};

struct P
{
    int x;
    int y;
} node[maxn];

void bfs(int num)
{
    int xx = node[num].x;
    int yy = node[num].y;
    if(Map[xx][yy] == 'D')
        return ;

    for(int i = 0; i < n; i++)
    {
        for(int j =0; j < m; j++)
            dis[num][i][j] = -1;
    }

    queue
 Q;
    Q.push(node[num]);
    dis[num][xx][yy] = 0;
    P tmp, cur;
    while(!Q.empty())
    {
        tmp = Q.front();
        Q.pop();

        for(int i = 0; i < 4; i++)
        {
            cur.x = tmp.x + x[i];
            cur.y = tmp.y + y[i];
            if(cur.x < 0 || cur.y < 0 || cur.x >= n || cur.y >= m ||
                    Map[cur.x][cur.y] == 'D' || dis[num][cur.x][cur.y] != -1)
                continue;

            dis[num][cur.x][cur.y] = dis[num][tmp.x][tmp.y] + 1;
            Q.push(cur);
        }
    }
}

bool check(int v)
{
    memset(dp, -1, sizeof(dp));
    dp[1 << start][start] = v;

    for(int i = 0; i < (1 << cnt); i++)
    {
        for(int j = 0; j < cnt; j++)
        {
            if(dp[i][j] == -1 || i & (1 << j) == 0)
                continue;
            if((i & goal) == goal)
                return true;

            for(int k = 0; k < cnt; k++)
            {
                if(i == j || (i & (1 << k)) != 0)
                    continue;
                int tmp = dis[j][node[k].x][node[k].y];
                if(dp[i][j] < tmp || tmp == -1)
                    continue;
                dp[i | (1 << k)][k] = max(dp[i | (1 << k)][k], dp[i][j] - tmp);
                if(Map[node[k].x][node[k].y] == 'G') dp[i | (1 << k)][k] = v;
            }
        }
    }
    return false;
}

int main()
{
    while(~scanf("%d %d", &n, &m), n + m)
    {
        goal = 0;
        cnt = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%s", Map[i]);
            for(int j = 0; Map[i][j]; j++)
            {
                if(Map[i][j]=='F')
                {
                    start=cnt;
                    goal|=(1<