我正在为N-Puzzle写一个求解器(见http://en.wikipedia.org/wiki/Fifteen_puzzle)
现在我正在使用unordered_map来存储拼图板的哈希值, 和曼哈顿距离作为算法的启发式算法,这是一个简单的DFS。
所以我有
auto pred = [](Node * lhs, Node * rhs){ return lhs->manhattanCost_ < rhs->manhattanCost_; };
std::multiset<Node *, decltype(pred)> frontier(pred);
std::vector<Node *> explored; // holds nodes we have already explored
std::tr1::unordered_set<unsigned> frontierHashTable;
std::tr1::unordered_set<unsigned> exploredHashTable;
这适用于n = 2和3。 然而,对于n = 4及以上,它真的很受欢迎。 (stl无法为新节点分配内存)
我还怀疑我在unordered_set中遇到哈希冲突
unsigned makeHash(const Node & pNode)
{
unsigned int b = 378551;
unsigned int a = 63689;
unsigned int hash = 0;
for(std::size_t i = 0; i < pNode.data_.size(); i++)
{
hash = hash * a + pNode.data_[i];
a = a * b;
}
return hash;
}
16! = 2×10 ^ 13(可能的安排)
2 ^ 32 = 4 x 10 ^ 9(32位散列中可能的散列值)
我的问题是如何优化我的代码来解决n = 4和n = 5? 我从这里知道 http://kociemba.org/fifteen/fifteensolver.html
http://www.ic-net.or.jp/home/takaken/e/15pz/index.html
平均可在不到一秒的时间内获得n = 4。
编辑: 算法本身就在这里:
bool NPuzzle::aStarSearch()
{
auto pred = [](Node * lhs, Node * rhs){ return lhs->manhattanCost_ < rhs->manhattanCost_; };
std::multiset<Node *, decltype(pred)> frontier(pred);
std::vector<Node *> explored; // holds nodes we have already explored
std::tr1::unordered_set<unsigned> frontierHashTable;
std::tr1::unordered_set<unsigned> exploredHashTable;
// if we are in the solved position in the first place, return true
if(initial_ == target_)
{
current_ = initial_;
return true;
}
frontier.insert(new Node(initial_)); // we are going to delete everything from the frontier later..
for(;;)
{
if(frontier.empty())
{
std::cout << "depth first search " << "cant solve!" << std::endl;
return false;
}
// remove a node from the frontier, and place it into the explored set
Node * pLeaf = *frontier.begin();
frontier.erase(frontier.begin());
explored.push_back(pLeaf);
// do the same for the hash table
unsigned hashValue = makeHash(*pLeaf);
frontierHashTable.erase(hashValue);
exploredHashTable.insert(hashValue);
std::vector<Node *> children = pLeaf->genChildren();
for( auto it = children.begin(); it != children.end(); ++it)
{
unsigned childHash = makeHash(**it);
if(inFrontierOrExplored(frontierHashTable, exploredHashTable, childHash))
{
delete *it;
}
else
{
if(**it == target_)
{
explored.push_back(*it);
current_ = **it;
// delete everything else in children
for( auto it2 = ++it; it2 != children.end(); ++it2)
delete * it2;
// delete everything in the frontier
for( auto it = frontier.begin(); it != frontier.end(); ++it)
delete *it;
// delete everything in explored
explored_.swap(explored);
for( auto it = explored.begin(); it != explored.end(); ++it)
delete *it;
return true;
}
else
{
frontier.insert(*it);
frontierHashTable.insert(childHash);
}
}
}
}
}
答案 0 :(得分:2)
由于这是作业,我会建议您尝试一些策略。
首先,尝试使用valgrind或类似的工具来检查内存泄漏。如果不删除新内容,可能会有一些内存泄漏。
其次,计算应探索的节点数量的界限。跟踪您探索的节点数量。如果您通过了绑定,则可能无法正确检测周期。
第三,尝试使用深度优先搜索而不是A *的算法。它的内存需求在树的深度应该是线性的,它应该只是改变排序顺序(pred)。如果DFS有效,您的A *搜索可能会探索太多节点,或者您的内存结构可能效率太低。如果DFS不起作用,那么循环可能会出现问题。
第四,尝试更紧凑的内存结构。例如,std :: multiset可以执行您想要的操作,但带有std :: deque的std :: priority_queue可能会占用更少的内存。您可以尝试其他更改,看看它们是否可以改进。
答案 1 :(得分:1)
首先我会推荐cantor expansion,您可以将其用作散列方法。它是1对1,即16!可能的安排将被打入 0~16! - 1 。
然后我会自己实现map
,你可能知道,std
对计算来说效率不高。 map
实际上是Binary Search Tree
,我建议使用Size Balanced Tree
,或者您可以使用AVL tree
。
仅供记录,直接使用bool hash[]
&amp; big prime
也可能会收到良好的效果。
然后最重要的事情 - A* function
,就像你链接的第一个内容一样,你可以尝试各种A* function
并找到最好的一个。
答案 2 :(得分:1)
您只使用启发式功能来订购多重集。您应该使用min(g(n) + f(n))
,即min(路径长度+启发式)来订购您的边界。
问题在于,你选择的是启发式最少的那个,这可能不是正确的“下一个孩子”。
我相信这是导致你的计算爆炸的原因。