实施贪婪的解决方案以解决8难题
Greedy.h：
class Greedy {
const string Goal = "12345678_";
State current;
string startState;
int nodesCreated, nodesExpanded;
priority_queue<State> greedyQueue;
set<string> visited;
stack<string> solutionStack;
public:
Greedy(const string start);
~Greedy();
void doGreedy();
};
Greedy.cpp：
tuple<int, int> getTarget(int n);
Greedy::Greedy(const string start) : startState(start), nodesCreated(0), nodesExpanded(0) {}
Greedy::~Greedy() {}
void Greedy::doGreedy() {
greedyQueue.emplace(startState, "");
while (!greedyQueue.empty()) {
current = greedyQueue.top();
greedyQueue.pop();
if (visited.find(current.stateString) == visited.end()) {
visited.insert(current.stateString);
if (current.stateString == Goal) { //end has been reached, calculate path, print out stats, and end.
cout << "Solution Found!" << endl;
//solutionStack.push(current.moveFromParent);
State* tempParent = current.parent;
while ( solutionStack.size() < 20 && tempParent != NULL) {
solutionStack.push(tempParent->moveFromParent);
tempParent = tempParent->parent;
}
break;
}
vector<State> childrenFound = current.expandNode();
for (int i = 0; i < childrenFound.size(); ++i) { // for each child found, add it to the priority queue, set its parent, and set it as a child of parent
State temp = childrenFound[i];
if (visited.find(temp.stateString) == visited.end()) { // We haven't been here before, put it in the queue
greedyQueue.push(temp);
}
}
}
}
cout << "Last 20 moves:" << endl;
while (!solutionStack.empty()) {
cout << solutionStack.top() << endl;
solutionStack.pop();
}
}
State.h：
class State {
public:
string moveFromParent;
State* parent;
string stateString;
int distance;
State();
State(const string str, State * _parent, string _moveFromParent);
State (const string str, string _moveFromParent);
State(const string str, int dist, State * _parent, string _moveFromParent);
~State();
bool operator<(const State & state) const;
bool operator==(const State & state) const;
int findBlank();
vector<State> expandNode();
};
State.cpp：
int manhattan(const string str);
tuple<int, int> getTarget(int n);
State::State() {}
State::State(const string str, State * _parent, string _moveFromParent) : stateString(str), moveFromParent(_moveFromParent) {
parent = _parent;
}
State::State(const string str, string _moveFromParent) : stateString(str), moveFromParent(_moveFromParent) {
parent = NULL;
distance = manhattan(stateString);
}
State::State(const string str, int dist, State* _parent, string _moveFromParent) : stateString(str), distance(dist), moveFromParent(_moveFromParent) {
parent = _parent;
distance = manhattan(stateString);
}
State::~State() {}
bool State::operator<(const State & state) const {
return distance > state.distance;
}
bool State::operator==(const State & state) const {
return ((stateString == state.stateString));
}
int State::findBlank() {
for (int i = 0; i < stateString.length(); ++i) {
if (stateString[i] == '_') {
return i;
}
}
}
vector<State> State::expandNode() {
vector<State> returnStates;
int blank = findBlank();
if (blank % 3 > 0) { // can move left
string newState = stateString;
newState[blank] = newState[blank - 1];
newState[blank - 1] = '_';
int heuristic = manhattan(newState);
State * childsParent = this;
string move = "left";
State temp = State(newState, heuristic, childsParent, move);
returnStates.push_back(temp);
}
if (blank % 3 < 2) { //can move right
string newState = stateString;
newState[blank] = newState[blank + 1];
newState[blank + 1] = '_';
int heuristic = manhattan(newState);
State * childsParent = this;
string move = "right";
State temp = State(newState, heuristic, childsParent, move);
returnStates.push_back(temp);
}
if (blank / 3 > 0) { //can move up
string newState = stateString;
newState[blank] = newState[blank - 3];
newState[blank - 3] = '_';
int heuristic = manhattan(newState);
State * childsParent = this;
string move = "up";
State temp = State(newState, heuristic, childsParent, move);
returnStates.push_back(temp);
}
if (blank / 3 < 2) { // can move down
string newState = stateString;
newState[blank] = newState[blank + 3];
newState[blank + 3] = '_';
int heuristic = manhattan(newState);
State * childsParent = this;
string move = "down";
State temp = State(newState, heuristic, childsParent, move);
returnStates.push_back(temp);
}
return returnStates;
}
int manhattan(const string str) {
int distance = 0;
for (int i = 0, length = str.length(); i != length; ++i) {
tuple<int, int> target;
if (str[i] == '_') {
target = { 2, 2 };
}
else {
int temp = str[i] - '0';
target = getTarget(temp);
}
tuple<int, int> current = getTarget(i + 1);
int localSum = abs(get<0>(current) - get<0>(target)) + abs(get<1>(current) - get<1>(target));
distance += localSum;
}
return distance;
}
tuple<int, int> getTarget(int n) {
return { (n - 1) / 3, (n - 1) % 3 };
}
我遇到了一个问题，即当我扩展更多节点时，指向State成员parent的指针会改变。
State有一个成员变量State * parent。这是用来在找到解决方案后返回到起点，以使解决方案移动。
扩展第一个节点后，优先级队列看起来很正常，所有节点的父级都是根节点，其父级为NULL。但是，在第二个节点之后，我的优先级队列中的节点都指向刚刚扩展的节点！这些应该指向自己的父母，而不应该捆绑在一起。我似乎在这里找不到我要去的地方，任何帮助将不胜感激。谢谢！
答案 0 :(得分：1)
问题出在Greedy::doGreedy和您对current的使用中。
分配current = greedyQueue.top();在队列中创建顶部对象的副本。稍后，当您调用vector<State> childrenFound = current.expandNode();时，所有返回的状态都有引用current的父指针。在下一次循环迭代中，您再次将该赋值分配给current，更改所有返回状态所指向的父级。
您的代码没有一个简单的解决方法。您需要重新考虑如何存储State对象，以使父对象保持原状并且不被修改。通常，这种事情是通过堆栈或列表完成的，将每个节点添加到末尾并弹出以向上移动到父节点。