First we try, then we trust

....，这要根据你测试的那一次具体程序运行的“路径”把
比如，刚好运行时的条件是moveleft2的
显然你优化后的moveleft2做的动作比优化前的多，那自然时间就长拉
  回复  引用    

我错了，没看清楚，不好意思
  回复  引用    

我想是这样的，首先CanMove...的判断并不会占多少时间，而导致时间延长的原因可能是因为改后改变了程序运行时最后一轮（即出最终答案的那一轮里答案出来的次序，也许本来是一上来就出现的，但现在变成最后才出来），如果换一个情况进行试验而时间和原来差不多的话，那这个猜测就是正确的。不知道是不是这样........
能不能看到你的最新的代码呢？
  回复  引用    

@Ya_Mu

在没有优化的情况下，我需要将所有的六次情况都判断一下。而修改后，即使最后一轮，也和原来一样判断五次就行了。没有任何区别。可效率确孑然不同。

最新的代码只是合并了些命名空间，删除了部分接口。你可以在老程序上将Layout项目中VChessman代码中的CheckAvailableSteps方法替换成下面的代码，然后在测试时测试NormalLayoutTest的运行时间，你就会发现其中的差异。如果其它棋子也修改的化，差异就更大了。

public override void CheckAvailableSteps(BlankPosition _blankPosition, CallBackDelegate _callback)
{
if(CanMoveLeft(_blankPosition))
{
_callback(_newPosition, _newBlankPosition, MoveMethod.Left);
return;
}

if(CanMoveRight(_blankPosition))
{
_callback(_newPosition, _newBlankPosition, MoveMethod.Right);
return;
}

if(CanMoveUp2(_blankPosition))
{
_callback(_newPosition, _newBlankPosition, MoveMethod.Up2);

// 设置棋子新位置
_newPosition.x = _position.x;
_newPosition.y = _position.y - 1;

// 设置新的空白位置
_newBlankPosition.Pos1.x = _position.x;
_newBlankPosition.Pos1.y = _position.y + 1;
_newBlankPosition.Pos2.x = _position.x;
_newBlankPosition.Pos2.y = _position.y - 2;

_callback(_newPosition, _newBlankPosition, MoveMethod.Up);

return;
}

if(CanMoveDown2(_blankPosition))
{
_callback(_newPosition, _newBlankPosition, MoveMethod.Down2);

// 设置棋子新位置
_newPosition.x = _position.x;
_newPosition.y = _position.y + 1;

// 设置新的空白位置
_newBlankPosition.Pos1 = _position;
_newBlankPosition.Pos2.x = _position.x;
_newBlankPosition.Pos2.y = _position.y + 3;

_callback(_newPosition, _newBlankPosition, MoveMethod.Down);

return;
}

if(CanMoveUp(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Up);

if(CanMoveDown(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Down);

return;
}
  回复  引用  查看    

上面代码的意思是说，一个竖放的棋子，如果能左移，则不会再有其它移动方法，因为只有两个空白位置，因此直接return，右移同理。

如果能上移两步，则一定能上移一步，除了这两种情况也没有别的什么情况，所以也可以return了。下移两步同理。

其它就是单独上移一步或下移一步了。从各方面将，该代码的判断次数都少于原来的判断次数，可效率确很差，不知怎么回事。
  回复  引用  查看    

我想你是没有理解我的意思，因为你用的是BFS，所以像金字塔一样，越到后来越慢，到最后一轮的运算差不多就是百万数量级的，所以如果正好本来是在那轮前面出来的，现在在后面出来的话，影响就差不多有1秒钟 （轮，就是你的那个“深度”）
您认为会不会是这个原因呢？
  回复  引用    

我想应当不是这个原因。我测试了一下，原有方法搜索层级是81层，搜索布局23844个，用时3.89秒；修该后搜索层级81层，搜索布局23844个，用时3.95秒。可以看到效率反而下降了，而深度与搜索的节点都没有变化。
  回复  引用  查看    

老大，你的Post里面的是对lLeft/Right进行优化，可是回复里面的代码里面怎么又是对Up/Down进行优化？

而且按照这里所看到的情况，应该是
if(CanMoveDown2(_blankPosition))
{
_callback(_newPosition, _newBlankPosition, MoveMethod.Down2);

_callback(_newPosition, _newBlankPosition, MoveMethod.Down);

return;
}

不太明白为什么有下面这些代码？感觉似乎是多余的，如果不是多余的估计就是有其他的缺陷。

// 设置棋子新位置
_newPosition.x = _position.x;
_newPosition.y = _position.y + 1;

// 设置新的空白位置
_newBlankPosition.Pos1 = _position;
_newBlankPosition.Pos2.x = _position.x;
_newBlankPosition.Pos2.y = _position.y + 3;

  回复  引用  查看    

@sumtec

我在评论中写的是一个竖放棋子。而文章中是一个横放棋子。

在我的华容道文章中写了基本算法：就是一个棋子的移动只与该棋子以及空格的位置有关，与其它棋子的位置无关。所以一旦棋子可以移动，我就算出移动后棋子的新位置以及空格的位置。所以一个竖放的棋子一旦可以向上移动两步，它一定可以向上移动一步。

在CanMoveUp2的代码中已经计算出了移动后棋子的新位置_newPosition和空格的新位置_newBlankPosition，所以直接callBack就可以了。然后的代码(下面的代码可能有所出入，但意思是这样的)：

// 设置棋子新位置
_newPosition.x = _position.x;
_newPosition.y = _position.y + 1;

// 设置新的空白位置
_newBlankPosition.Pos1 = _position;
_newBlankPosition.Pos2.x = _position.x;
_newBlankPosition.Pos2.y = _position.y + 3;

这是计算向上移动一格后棋子与空格的位置。

这样一个竖放棋子如果可以向上移动两格，那么它还可以向上移动一格，除此之外就没有其它的移动方法了，就可以直接RETURN了。这就是我的本意。可效率确不高。

我已经放弃这种优化了。
  回复  引用  查看    

@ 吕震宇 :

  回复  引用  查看    

@Sumtec

非常感谢提出这么多建议。我会考虑抽时间修改一下华容道程序的，出一个“性能优化版”，HashTable是一个非常好的数据结构设计，我会采纳进去，只 是HashCode的计算方法需要考虑一下。同时我考虑放弃4字节布局表示，这样排序操作也没有必要了，棋局改用64位二进制位表示（Int64）。理论 上性能应当进一步提升，内存占用有可能也会提升。

关于代码的问题，我在《华容道与数据结构 (6)》的Chessman设计中说明了callback的设计。这里是一个回调函数，根据当前布局以及棋子移动后的位置和空格位置生成一个新的布局。

CanMoveDown2函数用来判断当前棋子是否可以向下移动两格。如果可以，则计算出棋子新位置以及空格新位置（注意这个计算操作是在 CanMoveDown2函数中完成的），因此当CanMoveDown2返回逻辑真值时就直接callback。此时的newPosition与 newBlankPosition是由CanMoveDown2计算完成的值。在代码中就是：

//--------------------------------------------------------------
if(CanMoveDown2(_blankPosition))
{
  _callback(_newPosition, _newBlankPosition, MoveMethod.Down2);
//--------------------------------------------------------------

此时callback后，Layout就根据提供的数据生成了一个布局，该布局是当前棋子向下移动两格后的布局。到此还没有完，一个竖放棋子可以向下移动 两格则一定可以移动一格。所以下一步我们就没有必要再判断CanMoveDown了（CanMoveDown一定返回真），直接计算向下移动一格后棋子的 新位置与空格的新位置，然后callback，再让Layout生成另外一个全新的布局，该布局是棋子向下移动一格后的布局。

//--------------------------------------------------------------
// 设置棋子新位置（向下移动一格）
_newPosition.x = _position.x;
_newPosition.y = _position.y + 1;

// 设置新的空白位置
_newBlankPosition.Pos1 = _position;
_newBlankPosition.Pos2.x = _position.x;
_newBlankPosition.Pos2.y = _position.y + 3;

_callback(_newPosition, _newBlankPosition, MoveMethod.Down);
//--------------------------------------------------------------

关键在于，后一个callback是生成另外一个布局，该布局是向下移动一格棋子后的布局。此callback非彼callback。并且棋子不再可能有 其它的移动方法了，棋子一定不能左、右、上移动，直接return了。每次调用callback，系统就生成一个全新的布局供判断。不知道我这里有没有说 清楚这个问题。

  回复  引用  查看    

我原来就注意到MoveMethods.Down何Down2的区别了，知道此callback非比callback，这就是我原来所说的“有其他的缺陷”的意思。

那现在我明白了，我觉得：

// 设置棋子新位置（向下移动一格）
_newPosition.x = _position.x;
_newPosition.y = _position.y + 1;

// 设置新的空白位置
_newBlankPosition.Pos1 = _position;
_newBlankPosition.Pos2.x = _position.x;
_newBlankPosition.Pos2.y = _position.y + 3;

这几句话应该放到相应的CallBack函数里面去，这不是你这个CheckAvailableSteps函数的职责，应该是MoveMethod.Down里面的职责。你现在的写法至少是职责混乱，因为Down2的callback是计算并产生布局的，而Down则不计算只产生布局。如果你让我来写一个UpLeft的CallBack，我还真不知道该怎么写，到底要不要计算位置。因为从抽象的角度来看，所有的MoveMethod的抽象含义是一样的，但事实却不是如此。

如果更严格一点说，MoveMethods这一系列的回调函数，无论从命名的字面理解上看，还是从代码逻辑分析上看，都应该包含计算和产生两个步骤——其中计算只的是根据现有布局计算出新的布局的样式，而产生指的是将新的布局放到队列里面去（包括检查是否重复等逻辑）。
  回复  引用  查看    

@Sumtec

正如你所说，有些“职责混乱”。我也准备重构代码。不过有一点：callback只产生布局，而不进行任何计算。Down2是在CanMoveDown2函数中完成计算工作的，然后在CheckAvailableSteps函数中callback，可到了Down，就在CheckAvailableSteps函数中完成计算，然后callback，这就是“职责混乱”。

我现在还在使用：

public override void CheckAvailableSteps(BlankPosition _blankPosition, CallBackDelegate _callback)
{
if(CanMoveUp(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Up);

if(CanMoveDown(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Down);

if(CanMoveLeft(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Left);

if(CanMoveRight(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Right);

if(CanMoveLeft2(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Left2);

if(CanMoveRight2(_blankPosition))
_callback(_newPosition, _newBlankPosition, MoveMethod.Right2);

return;
}

来进行判断，以后我会考虑重新设计这部分内容。
  回复  引用  查看