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 = +;
 using namespace std;
 const int INF = <<;
 char s[maxn][maxn];
 int c[maxn][maxn], d[<<][], n;
 int dx[] = {, , , -};
 int dy[] = {, -, , };
 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, , sizeof(vis));
     ne.x = a; ne.y = b; ne.step = ;
     vis[a][b] = ;
     q.push(ne);
     while(!q.empty())
     {
         pos = q.front();
         q.pop();
         if(pos.x == c && pos.y == d)
         return pos.step;
         for(i = ; i < ; i++)
         {
             ne.x = pos.x+dx[i];
             ne.y = pos.y+dy[i];
             ne.step = pos.step+;
             if(!(ne.x>=&&ne.x<=n && ne.y>=&&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] = ;
         }
     }
     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, , sizeof(c));
         memset(s, , sizeof(s));
         for(i = ; i <= n; i++)
         {
             getchar();
             for(j = ; j <= n; j++)
             scanf("%c", &s[i][j]);
         }
         for(i = ; i < m; i++)
          cin>>x1[i]>>y1[i]>>x2[i]>>y2[i];
         for(i = ; i < m; i++)
         for(j = ; j < m; j++)
         {
             if(i == j) continue;
             c[i][j] = bfs(x2[i], y2[i], x1[j], y1[j]);
         }
         for(i = ; i < (<<m); i++)
         for(j = ; j < m; j++)
         d[i][j] = INF;

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

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