有哪位能告诉我样例中的第三个是怎么来的吗？

我觉得是7，怎么是5？

我和楼上的楼上ipip2005犯的同样错误

├ 测试数据 01：答案正确... 4025ms

├ 测试数据 02：答案正确... 4166ms

├ 测试数据 03：答案正确... 3838ms

├ 测试数据 04：答案正确... 4212ms

├ 测试数据 05：答案正确... 3978ms

├ 测试数据 06：答案正确... 3853ms

├ 测试数据 07：答案正确... 4025ms

├ 测试数据 08：答案正确... 3947ms

├ 测试数据 09：答案正确... 3994ms

├ 测试数据 10：答案正确... 3978ms

郁闷 同一个代码 同一个评测机 怎么今天交就AC 了···

大家hash 怎么设计啊？

7 8 9

1 2 3

4 5 6

7 8 9

1 4 3

2 5 6

4 8 9

1 7 3

2 5 6

4 8 9

1 5 3

2 7 6

4 9 8

1 5 3

2 7 6

4 1 8

9 5 3

2 7 6

4 3 8

9 5 1

2 7 6

这是样例第一个的方案，答案不应该是6吗？我晕死了，一个晚上了啊，还没看出什么

( 2008-7-17 20:29:02 )

编译通过...

├ 测试数据 01：答案正确... 2166ms

├ 测试数据 02：答案正确... 1931ms

├ 测试数据 03：答案正确... 1962ms

├ 测试数据 04：答案正确... 1900ms

├ 测试数据 05：答案正确... 1947ms

├ 测试数据 06：答案正确... 1900ms

├ 测试数据 07：答案正确... 1962ms

├ 测试数据 08：答案正确... 1962ms

├ 测试数据 09：答案正确... 2025ms

├ 测试数据 10：答案正确... 2056ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：19811ms

把所有8个九宫图全部丢进去BFS

编译通过...

├ 测试数据 01：答案正确... 1462ms

├ 测试数据 02：答案正确... 1416ms

├ 测试数据 03：答案正确... 1541ms

├ 测试数据 04：答案正确... 1416ms

├ 测试数据 05：答案正确... 1603ms

├ 测试数据 06：答案正确... 1462ms

├ 测试数据 07：答案正确... 1525ms

├ 测试数据 08：答案正确... 1291ms

├ 测试数据 09：答案正确... 1400ms

├ 测试数据 10：答案正确... 1416ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：14532ms

看了10遍题目。。终于看到了那个“但是不能”。。。。

单BFS 好慢 好慢

但还是1遍AC了。。。。。^_^

这样的搜索题说实话要不就全过要不就全不过- - 本人的悲惨经经历:First 内存益出(8维HASH) Second 内存溢出(40W字符串数组) Third 运行超时(反向搜索+全排列HASH) Fourth AC(1次反向搜索用对称旋转确定其他7种状态+全排列HAHS).让大牛见笑了,小菜的全排列HASH是O(9^2)的,才过不了.就算AC了也用了2S的时限-＿-

大家没想过用数学方法吗？

编译通过...

├ 测试数据 01：答案正确... 2588ms

├ 测试数据 02：答案正确... 2572ms

├ 测试数据 03：答案正确... 2603ms

├ 测试数据 04：答案正确... 2619ms

├ 测试数据 05：答案正确... 2556ms

├ 测试数据 06：答案正确... 2588ms

├ 测试数据 07：答案正确... 2588ms

├ 测试数据 08：答案正确... 2588ms

├ 测试数据 09：答案正确... 2603ms

├ 测试数据 10：答案正确... 2603ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：25908ms

热烈庆祝！！

BFS居然用了2000多MS...算了算了,谁叫我偷懒呢...

虽然有8个起点,但是他们经过旋转和对称后是相同的,也就是可以只考虑一个起始结点

所有状态都可以唯一的对应到一个排列的序号上,由于旋转和对称,8个状态可以对应同一个序号,节点数变为9!/8=45360个

我们只要在8种状态表示中选择最小的一种作为代表就行了...这样写MS会快一点...但是我没有去尝试...

放着5s的时限不用是浪费啊....

关键在于设计hash吧！

没啥说的,开HASH搜索

我提交的时候 它说我有非法字符 怎么回事啊 谁能告诉我啊！！！！

我可是花了5个小时编的啊 不能就这样泡汤了啊 ！！！

同志们帮帮我吧！！！

告诉我怎么回事！！！

编译通过...

├ 测试数据 01：答案正确... 4088ms

├ 测试数据 02：答案正确... 3791ms

├ 测试数据 03：答案正确... 3884ms

├ 测试数据 04：答案正确... 4009ms

├ 测试数据 05：答案正确... 4072ms

├ 测试数据 06：答案正确... 4212ms

├ 测试数据 07：答案正确... 4572ms

├ 测试数据 08：答案正确... 4728ms

├ 测试数据 09：答案正确... 4025ms

├ 测试数据 10：答案正确... 3447ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：40828ms

看来下次要学着写双向搜索了~

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

这是真的。。。吗？

有疑问请联系大号：楼上那个

编译通过...

├ 测试数据 01：答案正确... 41ms

├ 测试数据 02：答案正确... 56ms

├ 测试数据 03：答案正确... 41ms

├ 测试数据 04：答案正确... 41ms

├ 测试数据 05：答案正确... 41ms

├ 测试数据 06：答案正确... 56ms

├ 测试数据 07：答案正确... 41ms

├ 测试数据 08：答案正确... 56ms

├ 测试数据 09：答案正确... 41ms

├ 测试数据 10：答案正确... 56ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：470ms

此人BT，请勿模仿

编译通过...

├ 测试数据 01：答案正确... 1650ms

├ 测试数据 02：答案正确... 1666ms

├ 测试数据 03：答案正确... 1650ms

├ 测试数据 04：答案正确... 1650ms

├ 测试数据 05：答案正确... 1650ms

├ 测试数据 06：答案正确... 1681ms

├ 测试数据 07：答案正确... 1775ms

├ 测试数据 08：答案正确... 1650ms

├ 测试数据 09：答案正确... 1666ms

├ 测试数据 10：答案正确... 1650ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：16688ms

反向广搜+判重,判重我是用它在1~9！的全排列的位置来判重的，

用双向广搜估计更快一点。

---|-第101个AC者

编译通过...

├ 测试数据 01：答案正确... 2822ms

├ 测试数据 02：答案正确... 2838ms

├ 测试数据 03：答案正确... 2838ms

├ 测试数据 04：答案正确... 2822ms

├ 测试数据 05：答案正确... 2822ms

├ 测试数据 06：答案正确... 2838ms

├ 测试数据 07：答案正确... 2838ms

├ 测试数据 08：答案正确... 2838ms

├ 测试数据 09：答案正确... 2838ms

├ 测试数据 10：答案正确... 2838ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：28332ms

全给列出来了。。。然后按答案转化为123456789到当前点的距离直接取min

PS:想交表的（我想交来着……想来个0msAC）。。表好大。。900kb.交不上去，郁闷

简单的题目。

使用打表思想。先变一个程序把所有的合理队形求出来，发现只有8种。于是好办，从这八种出发，使用BFS把所有情况都计算一遍，就行了。

判重的时候可以使用全排列的编码，用Hash——你不觉得太浪费了吗？

没看到50组数据,用eof...可怜...