BestCoder14 1002.Harry And Dig Machine（hdu 5067） 解题报告

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5067

题目意思：给出一个 n * m 的方格，每一个小方格（大小为1*1）的值要么为 0 要么为一个正整数。规定是正整数的值得方格个数不超过 10 个。现在问从最左上角的点开始，要经过所有正整数的值的点之后，要返回到最左上角的点的最短路径是多少。

其实为正整数的那些点具体值是什么根本无关紧要。可以先求出所有点到其他点的两两最短路径，然后利用状态压缩 （考虑到只有10个点，状态数最多为2^10）来求出答案），题解是这样说的：

dp[i][j]：表示状态 i 的点被访问过了，当前停留在点 j 需要的最少时间。枚举另一个不在状态 i 内的点 k ， 从点 j 走到点 k 的状态转移方程为：

dp[i|(1<<k)][k] = min(dp[i|(1<<k)][k], dp[i][j] + dist(j, k))

其中，dist[j][k] 表示从点 j 与 点 k 的最短距离。所以可以利用 bfs（当然有更简单的解法，这里我是为了练手而已） 求出以每一个点作为出发点，求出以这个点到其他所有点的最短距离。

代码中的 dp 计算，和方程有一点点不同。有些地方不太理解，先留着吧。。。

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 using namespace std;

 const int maxn =  + ;
 const int INF = 0x3f3f3f3f;
 int n, m, cnt, st[maxn], end[maxn];
 int vis[maxn][maxn], hs[maxn][maxn];
 int dp[maxn][<<], dist[maxn][maxn];

 int dx[] = {, , , -};
 int dy[] = {, , -, };

 struct node
 {
     int x, y;
     int step;
 } cur, tmp;

 queue<node> q;

 void bfs(int id)
 {
     while (!q.empty())
         q.pop();
     memset(vis, , sizeof(vis));
     tmp.x = st[id], tmp.y = end[id];
     tmp.step = dist[id][id] = ;
     q.push(tmp);
     vis[st[id]][end[id]] = ;

     while (!q.empty())
     {
         tmp = q.front();
         q.pop();

         for (int i = ; i < ; i++)
         {
             int tx = tmp.x + dx[i];
             int ty = tmp.y + dy[i];
             if (tx >=  && tx <= n && ty >=  && ty <= m && !vis[tx][ty])
             {
                 vis[tx][ty] = ;
                 cur.x = tx;
                 cur.y = ty;
                 cur.step = tmp.step + ;
                 if (hs[tx][ty] != -)      // the target point's id
                     dist[id][hs[tx][ty]] = cur.step;
                 q.push(cur);
             }
         }
     }
 }

 void Init()
 {
     memset(hs, -, sizeof(hs));
     int val;
     cnt = ;
     for (int i = ; i <= n; i++)
     {
         for (int j = ; j <= m; j++)
         {
             scanf("%d", &val);
             if (val || i ==  && j == )
             {
                 st[cnt] = i;
                 end[cnt] = j;
                 hs[i][j] = cnt++;  // 为每一个大于0的点（最多只有10个）编号，第一个点编号为0而不是1
             }
         }
     }
 }

 int main()
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt", "r", stdin);
 #endif

     while (scanf("%d%d", &n, &m) != EOF)
     {
         Init();
         for (int i = ; i < cnt; i++)   // the shortest path from point i to other points
             bfs(i);
         int status = <<cnt;
         memset(dp, 0x3f, sizeof(dp));

         dp[][] = ;
         for (int i = ; i < status; i++)
         {
             for (int j = ; j < cnt; j++)
             {
                 if (dp[j][i] != INF)
                 {
                     for (int k = ; k < cnt; k++)
                     {
                         if (!(i & (<<k)))   // 点k不包含在状态i上
                             dp[k][i|(<<k)] = min(dp[k][i|(<<k)], dp[j][i]+dist[j][k]);
                     }
                 }
             }
         }
         printf("%d\n", dp[][status-]);
     }
     return ;
 }

代码中最后的输出 dp[0][status-1] 很明显就是从最左上角的点出发，经过所有正整数点的最短距离。不过为什么求的时候与二维数组dp[][]不同，这个确实不太理解。

　　精简版：

　　

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 using namespace std;
 typedef long long Int;
 typedef pair<int,int>pi;
 int n,m;
 vector<pi>V;
 int Map[][];
 int dp[][];
 int getdis(int u,int v)
 {
    if(!u)return V[v-].first+V[v-].second-;
    u--;v--;
    return abs(V[v].first-V[u].first)+abs(V[v].second-V[u].second);
 }
 void up(int &x,int y)
 {
    if(x==-||x>y)x=y;
 }
 int main()
 {
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
       V.clear();
       for(int i=;i<=n;i++)
          for(int j=;j<=n;j++)
          {
             int u;
             scanf("%d",&u);
             if(i==&&j==)continue;
             if(u>)
             V.push_back(pi(i,j));
          }
       if(!V.size()){puts("");continue;}
       memset(dp,-,sizeof(dp));
       dp[][]=;
       int mx=(<<V.size())-;
          for(int j=;j<mx;j++)
             for(int k=;k<=V.size();k++)
               if(dp[j][k]>=)
               {
                  for(int p=;p<V.size();p++)
                     if((j&(<<p))==)
                     {
                        up(dp[j|(<<p)][p+],dp[j][k]+getdis(k,p+));
                     }
               }
        int ans=-;
         for(int i=;i<V.size();i++)
           if(dp[mx][i+]>=)
             up(ans,dp[mx][i+]+getdis(,i+));
        printf("%d\n",ans);
    }
 }