Mines For Diamonds 【UVA - 10605】【启发式搜索+BFS】

[UVA 10605]钻石矿道

---

【题目描述】

给定一个n*m钻石矿区，你需要挖一些地道将所有的钻石挖出来：

一条地道是一条从边境出发的折线，途中覆盖的钻石都算采到，两条折线不能相交，但可以相邻，求最小的地道总长度

【输入格式】

多组数据，第一行为一个T(T<=10)，之后有T组数据。

每组数据第一行为两个整数n，m（3<=n,m<=11).

之后的n行，每行有m个字符,"."代表石头，"*"代表钻石，"#"代表矿区的边界。

【输出格式】

对于每组数据，输出最小的地道总长度。

【样例输入】

3
11 11
###########
##.########
#....######
#.*....####
#..*.....##
##....*...#
###....**.#
###.......#
###..*...##
####...####
###########
3 11
###########
#..*..*...#
###########
11 11
###########
##.########
#....######
#.*....####
#..*.....##
##....*...#
###....**.#
###....*..#
###..*...##
####...####
###########

【样例输出】

11
2
13

【提示】

对于第一组数据

我们可以这样挖地道

---

  然后，这道题的思想感觉像是状压的启发式搜索，因为这里的矿石的数量很少，所以可以直接去进行状压来存储这个，然后去处理出来所有的矿石到边界的最短距离，之后我们把它一个一个的合并起来，然后去看合并到现在的状态的（也就是现在集合里有的点）到边界的最短距离。

  用到了启发式搜索的估值函数h[ ]，先从只有一个点开始，往后不断的放点进来，用dp[i][j]去表示i状态下，我们同时还要放进j物品时候，我们把j与现有集合内的每个点进行合并去看哪个点与它最接近，然后合并起来。用g[i]表示i这个状态，我们出发的最优解。然后去看f[i]，去判断它应该是哪几个子集的合并。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(x, y) make_pair(x, y)
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 15;
const int dir[4][2] =
{
    -1, 0,
    0, -1,
    0, 1,
    1, 0
};
int N, M, tot, h[maxN], dp[1<<maxN][maxN], g[1<<maxN], f[1<<maxN];
char mp[maxN][maxN];
struct node
{
    int x, y;
    node(int a=0, int b=0):x(a), y(b) {}
}a[maxN * maxN];
inline int _dis(node e1, node e2) { return abs(e1.x - e2.x) + abs(e1.y - e2.y); }
bool vis[maxN][maxN];
typedef pair<node, int> pill;
queue<pill> Q;
inline int bfs(int sx, int sy)
{
    memset(vis, false, sizeof(vis));
    while(!Q.empty()) Q.pop();
    Q.push(MP(node(sx, sy), 0));
    vis[sx][sy] = true;
    while(!Q.empty())
    {
        pill now = Q.front(); Q.pop();
        for(int i=0, xx, yy; i<4; i++)
        {
            xx = now.first.x + dir[i][0]; yy = now.first.y + dir[i][1];
            if(vis[xx][yy]) continue;
            if(mp[xx][yy] == '#') return now.second + 1;
            vis[xx][yy] = true;
            Q.push(MP(node(xx, yy), now.second + 1));
        }
    }
    return 0;
}
inline void init()
{
    tot = 0;
    memset(dp, INF, sizeof(dp));
    memset(g, INF, sizeof(g));
    memset(f, INF, sizeof(f));
}
int main()
{
//    freopen("uva10605.in", "r", stdin);
//    freopen("uva10605.out", "w", stdout);
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &N, &M);
        init();
        for(int i=1; i<=N; i++)
        {
            scanf("%s", mp[i] + 1);
            for(int j=1; j<=M; j++)
            {
                if(mp[i][j] == '*') a[tot++] = node(i, j);
            }
        }
        for(int i=0; i<tot; i++) h[i] = bfs(a[i].x, a[i].y);    //把每个点的到达出口的最短路径求出来
        dp[0][0] = 0;
        for(int i=0; i<tot; i++) dp[1<<i][i] = h[i];    //每个独立的点都是h[i]
        for(int i=0; i<(1<<tot); i++)
        {
            for(int j=0; j<tot; j++)
            {
                if((1<<j) & i)  //j这个点在集合内
                {
                    for(int k=0; k<tot; k++)
                    {
                        if( ((1<<k) & i) && k != j )    //找一个在子集中的点，去更新最短路径
                        {
                            dp[i][j] = min(dp[i][j], dp[i ^ (1<<j)][k] + _dis(a[j], a[k]));
                        }
                    }
                }
            }
            for(int j=0; j<tot; j++)
            {
                g[i] = min(g[i], dp[i][j]); //i物品出去有没有更优的方案
            }
        }
        f[0] = 0;
        for(int i=1; i<(1<<tot); i++)   //每种状态的最优解
        {
            for(int j=1; j<=i; j++)
            {
                if((i & j) == j)
                {
                    f[i] = min(f[i], f[i^j] + g[j]);    //不断比较i的子集能否优化
                }
            }
        }
        printf("%d\n", f[(1<<tot) - 1]);
    }
    return 0;
}