Question

我正在编写一个模拟真空清洁房间的程序。有一个初始的脏点状态，我想使用各种AI算法来找到清洁房间的最佳路径。通过使算法与实际问题分开，我认为我的解决方案将非常模块化。

每种算法只了解国家。每个州都可以扩展到儿童州。这是我的第一个算法，UniformCost：

#include<iostream>
#include<set>

class State {
public:
    State(){}
    bool operator< (const State& s) const;
    bool isGoal();
    std::set<State> expand();
};


class UniformCost {
private:
    State startState;
    std::set<State> closedList; //list of no repeated states
public:
    State start;
    void setStart(State s);
    State* getSolution();
};

void UniformCost::setStart(State st) {
    start = st;
}

State* UniformCost::getSolution() {
    closedList.insert(start);
    while(!closedList.empty()) {
        State cur = *closedList.begin();
        if(cur.isGoal()) {
            return &cur;
        }
        closedList.erase(cur);
        std::set<State> children = cur.expand();
        for (std::set<State>::iterator i = children.begin(); i != children.end(); ++i) {
            closedList.insert(*i);
        }
    }
}

我的主应用程序创建初始Node，它是State的子类。

class Node : public State {
public:
    std::pair<int,int> loc;
    int g_val;
    std::set<std::pair<int,int> > dirt;
    std::vector<char> path;

    bool isGoal() {
        return dirt.size() == 0;
    }
    bool operator< (const State& s) const {
        Node n = (Node) s;
        if(loc == n.loc) {
            return false;
        }
        if(g_val <= n.g_val) {
            return true;
        }
        return false;
    }
    std::set<State> expand() { 
        std::set<State> ret;
        return ret;
    }
};

如何在Node类中覆盖期望“operator＆lt;（const State＆amp;）”的运算符？或者是一个更普遍的问题，我将如何处理未来的国家“铸造”？

覆盖子类中的运算符

0 个答案: