POJ 1178 Camelot (floyed算法)

本题没有读懂题目，想偏后导致各种不顺。我理解的是每个骑士间和国王都可以同步的移动。原来是一次只能移动一个人，求总步数最小。于是就简单多了。开始想歪后，在论坛找到一种说法：预处理+纯暴力。原文说“枚举64个终点 * 枚举64个接国王点 * 枚举64只来接的骑士 总复杂度O(64*64*64)”。这时候我才明白原来题目意思是要求求所有步数的最小值。Google题目的翻译。

这里是题目链接。题目大意：棋盘上有1个国王和若干个骑士，要把国王和每个骑士移动到同一个格子内，问需要移动的最小步数是多少。如果国王和骑士走到同一个格子里，可以由骑士带着国王一起移动。参考来源

题目转化为2张图，国王为点（实际上每一个格子都是点），每一个点到采用国王移动规则移到的另一个点为一条权值为1的边。Floyd算法可以算出每两点之间的最短路径，也就是国王从一点移动到另一点的最短步数。另外一张骑士的图同理。

于是算法转化为以上第一段说的三个枚举。我的代码如下：

   1: #include <iostream>

   2: #include <string>

   3: #include <algorithm>

   4:  

   5: using namespace std;

   6: const int MAX_INT = (1<<15);

   7: const int SQUARE_SIZE = 64;

   8:  

   9: int kings[SQUARE_SIZE][SQUARE_SIZE];

  10: int knights[SQUARE_SIZE][SQUARE_SIZE];

  11: int people[SQUARE_SIZE];

  12: const int kingsStep[8][2] = {{-1,-1},{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1}};

  13: const int knightsStep[8][2] = {{-1,-2},{-2,-1},{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2}};

  14:  

  15: void initGraph()

  16: {

  17:     for (int i=0; i<SQUARE_SIZE; i++)

  18:     {

  19:         for (int j=0; j<SQUARE_SIZE; j++)

  20:             kings[i][j] = knights[i][j] = (i==j ? 0:MAX_INT); 

  21:     }

  22:     for (int i=0; i<SQUARE_SIZE; i++)

  23:     {

  24:         int fromX=i/8, fromY=i%8;

  25:         int toX, toY;

  26:         for (int j=0; j<8; j++)

  27:         {

  28:             toX=fromX+kingsStep[j][0];

  29:             toY=fromY+kingsStep[j][1];

  30:             if (toX>=0 && toX<8 && toY>=0 && toY<8)

  31:                 kings[i][8*toX+toY] = 1;

  32:             

  33:             toX=fromX+knightsStep[j][0];

  34:             toY=fromY+knightsStep[j][1];

  35:             if (toX>=0 && toX<8 && toY>=0 && toY<8)

  36:                 knights[i][8*toX+toY] = 1;

  37:         }

  38:     }

  39: }

  40:  

  41: void floyd()

  42: {

  43:     for (int k=0; k<SQUARE_SIZE; k++)

  44:     {

  45:         for (int i=0; i<SQUARE_SIZE; i++)

  46:         {

  47:             for (int j=0; j<SQUARE_SIZE; j++)

  48:             {

  49:                 kings[i][j] = min(kings[i][j], kings[i][k]+kings[k][j]);

  50:                 knights[i][j] = min(knights[i][j], knights[i][k]+knights[k][j]);

  51:             }

  52:         }

  53:     }

  54: }

  55:  

  56: int main()

  57: {

  58:     initGraph();

  59:     floyd();

  60:     string s;

  61:     cin >> s;

  62:     int count=s.size()/2;

  63:     for (size_t i=0, j=0; i<s.size(); i=i+2,j++)

  64:         people[j] =(s[i]-'A')+(s[i+1]-'1')*8;

  65:     

  66:     int res=MAX_INT;

  67:     int sum=0;

  68:     for (int end=0; end<SQUARE_SIZE; end++)

  69:     {

  70:         sum = 0;

  71:         for (int j=1; j<count; j++)

  72:             sum += knights[people[j]][end];

  73:         if (sum>res)    continue;

  74:         

  75:         for (int meet=0; meet<SQUARE_SIZE; meet++)

  76:         {

  77:             int step1=kings[people[0]][meet];

  78:             int step2=MAX_INT;

  79:             for (int k=1; k<count; k++)

  80:                 step2 = min(step2, knights[people[k]][meet]+knights[meet][end]-knights[people[k]][end]);

  81:             res = min(res, sum+step1+step2);

  82:         }

  83:     }

  84:     cout << res << endl;

  85:     s.clear();

  86:     return 0;

  87: }