hdu 5067 Harry And Dig Machine (状态压缩dp)

题目链接

bc上的一道题，刚开始想用这个方法做的，因为刚刚做了一个类似的题，但是想到这只是bc的第二题，

以为用bfs水一下就过去了，结果MLE了，因为bfs的队列里的状态太多了，耗内存太厉害。

题意：

从某一点出发，遍历网格上的一些点，每个点至少访问一次需要的最小时间是多少。

官方题解：

由于Harry的dig machine是无限大的，而装载石头和卸载石头是不费时间的，所以问题可以转化成：从某一点出发，遍历网格上的一些点，每个点至少访问一次需要的最小时间是多少。这就是经典的旅行商问题，考虑到我们必须要遍历的点只有不到10个，可以用状态压缩解决。
Dp[i][j]表示i状态的点被访问过了，当前停留在点j 需要的最少时间。枚举另一点不在i状态内的点k，从点j节点走向点k，状态转移
Dp[i|(1≪k)][k]=min(Dp[i|(1≪k)][k],Dp[i][j]+Dis(j,k))
其中Dis(j,k)表示点j与点k的最短距离，这个可以通过坐标O(1)计算得到。若有t个点包含石头，则算法复杂度为O(n∗m+(t2)∗(2t))。

 #include <iostream>
 #include <cstdio>
 #include <cmath>
 #include <queue>
 #include <cstring>
 #include <cstdlib>
 #include <algorithm>
 #define LL __int64
 #define INF 0x3f3f3f3f
 const int maxn = +;
 using namespace std;
 struct node
 {
     int x, y;
 } p[maxn];
 int a[maxn][maxn], c[maxn][maxn], d[(<<)+][];

 int main()
 {
     int i, j, k, n, m, cnt;
     while(~scanf("%d%d", &n, &m))
     {
         memset(d, INF, sizeof(d));
         cnt = ;
         for(i = ; i < n; i++)
             for(j = ; j < m; j++)
             {
                 scanf("%d", &a[i][j]);
                 if(i ==  && j == )
                 {
                     p[cnt].x = i;
                     p[cnt++].y = j;
                 }
                 else if(a[i][j]>)
                 {
                     p[cnt].x = i;
                     p[cnt++].y = j;
                 }
             }
         for(i = ; i < cnt; i++)
         {
             for(j = i+; j < cnt; j++)
             {
                 c[i][j] = c[j][i] = abs(p[i].x-p[j].x)+abs(p[i].y-p[j].y);
             }
             c[i][i] = ;
         }
         d[][] = ;
         for(i = ; i < (<<cnt); i++)
         {
             for(j = ; j < cnt; j++)
                 if(d[i][j]!=INF)  //注意保证该状态存在
                     for(k = ; k < cnt; k++)
                     {
                         if(i&(<<k)) continue;  //注意保证该点还没有加入
                         if(c[j][k]==INF) continue;  //两个点之间可达
                         d[i|(<<k)][k] = min(d[i|(<<k)][k], d[i][j]+c[j][k]);
                     }
         }
         int ans = INF;
         for(i = ; i < cnt; i++)
             ans = min(d[(<<cnt)-][i]+c[][i], ans);
         cout<<ans<<endl;
     }
     return ;
 }