A *和N-Puzzle优化

时间:2012-02-07 05:58:07

标签: c++ algorithm

我正在为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);
            }
        }
    }
}

}

3 个答案:

答案 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(路径长度+启发式)来订购您的边界。

问题在于,你选择的是启发式最少的那个,这可能不是正确的“下一个孩子”。

我相信这是导致你的计算爆炸的原因。