hdu 4856 Tunnels (bfs + 状压dp)

题目链接

The input contains mutiple testcases. Please process till EOF.
For each testcase, the first line contains two integers N (1 ≤ N ≤ 15), the side length of the square map and M (1 ≤ M ≤ 15), the number of tunnels.
The map of the city is given in the next N lines. Each line contains exactly N characters. Barrier is represented by “#” and empty grid is represented by “.”.
Then M lines follow. Each line consists of four integers x₁, y₁, x₂, y₂, indicating there is a tunnel with entrence in (x₁, y₁) and exit in (x₂, y₂). It’s guaranteed that (x₁, y₁) and (x₂, y₂) in the map are both empty grid.

Output

For each case, output a integer indicating the minimal time Bob will use in total to walk between tunnels.
If it is impossible for Bob to visit all the tunnels, output -1.

题意:

一个边长为n的正方形网格图，其中有一些点' . '表示可达，' # '表示不可达，你不能走到不可达的点上，以及每一个单位时间你只能走到相邻的网格（上下左右）。现在给你m条密道，每条密道起始位置(x1,y1)，终点位置(x2,y2)，当你从起点进去后能瞬间从终点位置出来（不花时间），但是每条密道你只能走一遍。现在，你可以选择任意一个可达的点作为起点，问能否在满足条件下走完所有的密道，有解输出最短时间，否则输出-1。

分析：

先用bfs处理出来每个隧道之间的距离，然后就是走的各个隧道之间的顺序，可以用状压dp来做，

dp[ i ][ j ]表示已经经过的密道状态为 i （i为压缩状态，二进制的每一位表示相应的密道是否已经走过，走过为1，否则为0），最后一个经过的密道是j时的最小用时。

状态转移方程为：dp[ i | ( 1 << k ) ][ k ]  = min { dp[ i | ( 1 << k ) ][ k ] , dp[ i ][ j ] + dist[ j ][ k ] } 。
其中必须保证dp[ i ][ j ]已经有了的状态，dist[ j ][ k ]不是INF ( j 出发能到达 k )，以及状态 i 中不包含第 k 个密道能才发生转移。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <queue>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#define LL __int64
const int maxn = 20+10;
using namespace std;
const int INF = 1<<28;
char s[maxn][maxn];
int c[maxn][maxn], d[1<<17][20], n;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
struct node
{
    int x, y, step;
}pos, ne;
int bfs(int a, int b, int c, int d)
{
    queue<node>q;
    int vis[maxn][maxn], i;
    memset(vis, 0, sizeof(vis));
    ne.x = a; ne.y = b; ne.step = 0;
    vis[a][b] = 1;
    q.push(ne);
    while(!q.empty())
    {
        pos = q.front();
        q.pop();
        if(pos.x == c && pos.y == d)
        return pos.step;
        for(i = 0; i < 4; i++)
        {
            ne.x = pos.x+dx[i];
            ne.y = pos.y+dy[i];
            ne.step = pos.step+1;
            if(!(ne.x>=1&&ne.x<=n && ne.y>=1&&ne.y<=n)) continue;
            if(s[ne.x][ne.y]=='#') continue;
            if(vis[ne.x][ne.y]) continue;
            q.push(ne);
            vis[ne.x][ne.y] = 1;
        }
    }
    return INF;
}
int main()
{
    int m, i, j, k, ans;
    int x1[maxn], y1[maxn], x2[maxn], y2[maxn];
    while(~scanf("%d%d", &n, &m))
    {
        memset(c, 0, sizeof(c));
        memset(s, 0, sizeof(s));
        for(i = 1; i <= n; i++)
        {
            getchar();
            for(j = 1; j <= n; j++)
            scanf("%c", &s[i][j]);
        }
        for(i = 0; i < m; i++)
         cin>>x1[i]>>y1[i]>>x2[i]>>y2[i];
        for(i = 0; i < m; i++)
        for(j = 0; j < m; j++)
        {
            if(i == j) continue;
            c[i][j] = bfs(x2[i], y2[i], x1[j], y1[j]);
        }
        for(i = 0; i < (1<<m); i++)
        for(j = 0; j < m; j++)
        d[i][j] = INF;

        for(i = 0; i < m; i++)
        d[1<<i][i] = 0;

        for(i = 0; i < (1<<m); i++)
        for(j = 0; j < m; j++)
        if(d[i][j]!=INF)
        for(k = 0; k < m; k++)
        {
            if(!(i&(1<<k)) && c[j][k]!=INF)
            d[i|(1<<k)][k] = min(d[i|(1<<k)][k], d[i][j]+c[j][k]);
        }
        ans = INF;
        for(i = 0; i < m; i++)
        ans = min(ans, d[(1<<m)-1][i]);
        if(ans == INF) printf("-1
");
        else
        printf("%d
", ans);
    }
    return 0;
}