hdu 3681 Prison Break

最新推荐文章于 2020-03-30 23:49:07 发布

原创最新推荐文章于 2020-03-30 23:49:07 发布 · 362 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#hdu #搜索 #bfs #二分 #状压

搜索同时被 3 个专栏收录

21 篇文章

订阅专栏

最短路/查分约束

10 篇文章

订阅专栏

4 篇文章

订阅专栏

本文介绍了一种解决特定矩阵遍历问题的方法，通过结合二分查找与状态压缩动态规划来寻找最小电量需求，实现对所有指定节点的有效访问。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：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<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#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<P> 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<<cnt);
                    node[cnt].x=i;
                    node[cnt].y=j;
                    cnt++;
                }
                else if(Map[i][j]=='G')
                {
                    node[cnt].x=i;
                    node[cnt].y=j;
                    cnt++;
                }
                else if(Map[i][j]=='Y')
                {
                    goal|=(1<<cnt);
                    node[cnt].x=i;
                    node[cnt].y=j;
                    cnt++;
                }
            }
        }
        for(int i = 0; i < cnt; i++)
        {
            bfs(i);
        }
        int l=0,r=n*m;
        int ans=-1;
        while(l<=r)//二分答案，求结果
        {
            int mid=(l+r)/2;
            if(check(mid))
            {
                ans=mid;
                r=mid-1;
            }
            else l=mid+1;
        }
        cout << ans << endl;
    }
    return 0;
}