我正在尝试建立一个程序，比较算法BFS的笔画数和两个不同的A *（有两个启发式）在十五岁的游戏中。
我的问题是，计数器对BFS和A * 的三个计数器数组计算相同的结果。然而，我实际上使用了来自main（类Project）的三个不同的数组，并且我为这些笔划分配了三个不同的变量。
我认为问题来自A *。对于他们每个人，我从父亲开始，然后计算它的启发式并将他添加到边境。
虽然边境不是空的，但我看看初始状态是否是十五岁游戏的最终状态，否则我将其从边境移除并搜索他的儿子。我为它们设置了g值，我计算每个启发式算法以最终得到它们的f值。如果他们还没有进入边境，我会将它们添加到其中。然后我将边界中第一个的F值与边界中的每一个进行比较，并将具有最佳F值的F值实例化为current_state。
int best_f_value=frontier.get(0).getFValue();
for(State s : frontier){
if(s.getFValue()<=best_f_value){
best_f_value=s.getFValue();
current_state=s;
}
}
然而，当寻找计数器时，对于BFS和A *，我总是具有相同数量的笔划，其中错位瓦片的数量是启发式的，而Manhatan距离的启发式则是A *。这可能会出现一次，但并不总是!!
我认为问题在于A *的功能而不是用于计算其启发式的功能。因此，这里是第二个A *的代码，他看起来像第一个错位的瓷砖heurisitc。
public State aStar2(){
State child;
System.out.println("we entered A_star with Manhattan distance");
System.out.println("final:\n"+finalState);
/** current state of dfs algorithm **/
State current_state;
current_state = initialState;
current_state.computeHeuristic2();
current_state.computeValueF2();
//int best_f_value= current_state.getFValue();
int current_state_g_value = 0;
System.out.println(initialState);
// get alwhile(!frontier.isEmpty()){l possible actions from the given node
List<Action> actions = current_state.getActions();
//frontier is a Stack displaying not currently explored nodes
LinkedList<State> frontier = new LinkedList<State>();
// frontier already contains the first node
frontier.push(initialState);
// explored_nodes contains all explored nodes.
LinkedList<State> explored_nodes = new LinkedList<State>();
// this List is used to show the path
LinkedList<State> path = new LinkedList<State>();
while(!frontier.isEmpty()){
number_of_strokes_A2+=1;
// we found the goal
if(goal_test(current_state)){
for(State visited :path){
System.out.println(visited);
}
array_number_of_strokes_A2.add(number_of_strokes_A2);
System.out.println("nombre de coups A2 : " + number_of_strokes_A2);
number_of_strokes_A2=0;
System.out.println("on a réussi : \n" + current_state);
return current_state;
}
// We remove the current state from the frontier
// VERIFY THIS IS OKAY !!!
frontier.remove(current_state);
// We get all possible actions from the current state
actions = current_state.getActions();
// We add the current state to already explored nodes
explored_nodes.add(current_state);
//System.out.println(current_state);
path.add(current_state);
current_state_g_value = current_state.getValueG();
// We create every child
for (Action action : actions){
// we get a child from the execution of the current_state
child = current_state.execute(action);
child.setValueG(current_state_g_value);
child.computeHeuristic2();
child.computeValueF2();
if(!explored_nodes.contains(child)&&!frontier.contains(child)){
// This child not being already explored nor int the frontier we add it to the last one
frontier.add(0,child);
}
}
int best_f_value=frontier.get(0).getFValue();
for(State s : frontier){
if(s.getFValue()<=best_f_value){
best_f_value=s.getFValue();
current_state=s;
}
}
}
return finalState;
}
问我是否需要比较第一个A *。 以下是启发式方法。
他们在另一个档案中。我不认为他们犯了什么罪。
public void computeValueF(){
// to be completed
f_value = getValueG() + getHeuristic();
}
public void computeValueF2(){
// to be completed
f_value = getValueG() + getHeuristic2();
}
public int getFValue(){
return f_value;
}
@Override
public int getFValue2(){
return f_value;
}
public int getHeuristic(){
return h_value;
}
public int getHeuristic2(){
//somme de la distance de Manhattan entre lemplacement couvrant de chaque case � sa position finale
int h2=0;
for(int i=0;i<9;i++){
h2+=Integer.valueOf(puzzle.charAt(i))%3-i%3+Integer.valueOf(puzzle.charAt(i))/3-i/3;
}
return h2;
// to be completed
}
@Override
public int compareTo(Searchable<Puzzle, PuzzleAction> o) {
// TODO Auto-generated method stub
if(this.getHeuristic()> o.getHeuristic());
return 0;
}
@Override
public void setValueG(int cost) {
// TODO Auto-generated method stub
g_value = cost+1;
}
@Override
public int getValueG() {
// TODO Auto-generated method stub
return g_value;
}
@Override
public void computeHeuristic() {
// TODO Auto-generated method stub
//nombre de cases mal placees
for(int i=0;i<9;i++){
if((Integer.valueOf(puzzle.charAt(i))-i)!=0){
h_value+=1;
}
}
}
@Override
public void computeHeuristic2() {
// TODO Auto-generated method stub
int h2=0;
for(int i=0;i<9;i++){
h2+=Integer.valueOf(Math.abs(puzzle.charAt(i))%3-i%3)+Math.abs(Integer.valueOf(puzzle.charAt(i))/3-i/3);
}
this.h2_value=h2;
}
以下是笔画数的结果：
strokes BFS : [9, 7, 33, 33, 53, 53, 51]
strokes AStar1[9, 7, 33, 33, 53, 53, 51]
strokes AStar2[9, 7, 33, 33, 53, 53, 51]
这个问题与this one answered by Ishamael类似，但在实施BFS和DFS方面存在差异
Ishmael对我的启发式保持不变是正确的。因此，我尝试修改启发式计算方法，以便引用当前状态，而不是永远不会改变的东西。这是Puzzle.java中的方法
@Override
public void computeHeuristic1(String s) {
// TODO Auto-generated method stub
//nombre de cases mal placees
h1_value=0;
for(int i=0;i<9;i++){
if((Integer.valueOf(s.charAt(i))-i)!=0){
h1_value+=1;
}
}
}
我们将在Problem.java中使用
child.computeHeuristic1(child.toString());
如果需要，我可以添加更多代码。
我得到那些启发式：
array_heuritics_1 : [9, 9, 9, 9, 9, 9, 9, 9
array_heuritics_2 : [130, 131, 131, 129, 129, 128, 1
最后一个是异常的，只要每个图块最多可以带来3 + 3启发式值。因此，使用启发式＆gt; 51是站不住脚的。
所以我试图展示测试正在做什么，我发现了一些有趣的东西：
the child.toString :
1 2 5
3 4 .
6 7 8
the value :
i : 0 & s.charAt(i) : 1
i : 1 & s.charAt(i) : .
i : 2 & s.charAt(i) : 2
i : 3 & s.charAt(i) :
i : 4 & s.charAt(i) :
i : 5 & s.charAt(i) :
i : 6 & s.charAt(i) :
i : 7 & s.charAt(i) : 6
i : 8 & s.charAt(i) : 7
i : 0 & s.charAt(i) : 1
i : 1 & s.charAt(i) : .
i : 2 & s.charAt(i) : 2
i : 3 & s.charAt(i) :
i : 4 & s.charAt(i) :
i : 5 & s.charAt(i) :
i : 6 & s.charAt(i) :
i : 7 & s.charAt(i) : 6
i : 8 & s.charAt(i) : 7
实际上我们不是用数字来做测试数字而是用char做char并且有一些空白！
答案 0 :(得分：2)
首先，让我们考虑如果您的A *没有使用任何启发式（如果getFValue刚刚返回getValueG）会发生什么。请注意，当算法启动时，它只在frontier中有一个节点，因此将被选中。在每次连续迭代中，边界中的值将按降序排列cost（如果您在纸上绘制几个示例，则可以通过归纳来证明），并且边界中第一个元素的成本将是要么等于最后一个或一个更大的成本。现在当您运行选择state的循环时，您将始终选择最后一个元素，因为它将具有最小的FValue，其中您始终选择最后一个元素。换句话说，如果启发式没有到位，那么A*的行为就像你的BFS（它已经只选择了最后一个元素）。
现在让我们说你的启发式只是一个常数，例如你的getFValue被实现为return getValueG + constant。您可以通过遵循与上述非常相似的逻辑再次显示它的行为就像它只是BFS一样 - 如果您为比较的值添加常量，它们将以相同的方式进行比较。
最后，很容易证明您的启发式方法总是返回相同的值。请注意，它们仅取决于puzzle，它是常量。它们决不依赖于代理的当前位置。曼哈顿距离启发式应该将曼哈顿距离从当前位置加到地图上的所有目标位置（或者更确切地说，最接近的那个将作为启发式更有意义）。相反，它计算的东西根本不依赖于当前的位置，这是错误的。由于我在上面提供的原因，它返回的值总是相同的，它的行为类似于BFS。