Question

目前我正在尝试为类似国际象棋的游戏开发AI，我基本上尝试计算前面的几步，然后用alpha beta获得最佳的回报。

目前我的策略是，每动作一次，做出4个最佳结果动作，改变＆＃34; board＆＃34;暂时，然后对于那4个动作，再次召唤4个动作，然后进行动作，每次动作再召唤4个......

对于递归函数来说这似乎很自然，我试图一直向下挖掘10次左右。但到目前为止，我已经写了3个步骤（轮到我，你的，我的），我的代码已经爆炸了。我需要编写FOR EACH新动作的部分，计算新动作。无论如何我可以截断下面的代码，所以它可以像递归调用（...）一样以最大级别检查作为基本情况？

这是我当前的迭代3步代码，假设有一个树结构，每个移动内部包含4个最佳计数器移动的arraylist。

 for (i = 0; i < root.children.size(); i++) {
        root.children.get(i).runStrat();
        root.children.get(i).printNode();
        for (int lvl1 : root.children.get(i).currOtherPieces) {
            root.children.get(i).addChild(lvl1,root.children.get(i).level + 1);         
            }
        for (j = 0; j < root.children.get(i).children.size(); j++) {
            root.children.get(i).children.get(j).runStrat();
            System.out.print("    ");
            root.children.get(i).children.get(j).printNode();
            for (int lvl2 : root.children.get(i).children.get(j).currSelfPieces) {
                root.children.get(i).children.get(j).addChild(lvl2, root.children.get(i).children.get(j).level + 1);
            }
            for (k = 0; k < root.children.get(i).children.get(j).children.size(); k++) {
                root.children.get(i).children.get(j).children.get(k).runStrat();
                System.out.print("            ");
                root.children.get(i).children.get(j).children.get(k).printNode();
            }
        }
    }

正如您所看到的，我可以继续编写7个for循环层，但也许有一种巧妙的方法来递归地放置它。有帮助吗？谢谢！

（带空格的sys.out只供我调试，可以把它留下......）

Answer 1

你在做什么就是所谓的行为树遍历＆＃34;或者＆＃34;解空间搜索＆＃34;，即枚举所有可能的下一步动作并评估它们。行为树遍历只是tree traversal methods的一个应用程序。

虽然建议您充分了解广度优先树遍历和深度优先树遍历策略，但我可以快速回答您的问题。

在处理树遍历时，您可能更喜欢迭代算法到递归算法，因为如果您不进行尾递归优化，则可能会遇到堆栈溢出问题。

遍历树时，您应使用名为＆＃34; fringe＆＃34;的队列，其中包含要访问的下一个节点。

Queue<Node> fringe = new LinkedList<Node>();

首先，边缘将仅包含根节点。

fringe.add(root);

然后，你可以用这种方式迭代边缘：

while(fringe.isEmpty() == false) {
  Node current = fringe.poll();

  // Evaluate the current move, e.g. if it leads to an improvement of your gameplay
  boolean result = doSomething(current); 

  if(result && !current.getChildren().isEmpty()) {
     fringe.addAll(current.getChildren();
  }
}

此算法是BST（广度优先遍历）的一个简单实现，这意味着您在移动到下一个之前访问给定树级别的子节点。 DFS（Deep First Traversal）版本使用边缘的FIFO数据结构。

Stack<Node> fringe = new LinkedList<Node>();
fringe.push(root);

while(fringe.isEmpty() == false) {
  Node current = fringe.pop();

  // Evaluate the current move, e.g. if it leads to an improvement of your gameplay
  boolean result = doSomething(current); 

  if(result && !current.getChildren().isEmpty()) {
     for(Node child: current.getChildren()) {
        fringe.push(child);
     }
  }
}

对这两种算法进行了大量优化，例如根据某些指标（启发式方法，如A star）处理具有不同顺序的子节点，其他算法跟踪已访问过的节点以避免周期等等。

为了更好地掌握解决方案空间访问，我建议您阅读"Artificial Intelligence: A Modern Approach" by Stuart Russel and Peter Norvig。

为了保持搜索深度的计数，您可以使用名为level的字段扩展Node对象，对于root是0。在探索节点的子节点之前，在将它们插入边缘之前，只需设置它们的级别在父级+ 1级，如果这大于你的最高级别，只要避免将它们放在边缘。

Answer 2

以下是我如何翻译您的递归内容：

public static void dive(final int maxDives) {
    dive(root, 0, maxDives);
}

public static void dive(Node current, final int level, final int maxDives) {
    for(Node n : current.children) {
        n.runStrat();
        n.printNode();

        if(level < maxDives) {
            for (int lvl : n.currOtherPieces) {
                n.addChild(lvl, n.level + 1);
            }

            for(Node m : n.children) {
                dive(m, level + 1, maxDives);
            }
        }
    }
}

我不知道你的节点类型，所以我只是放入Node。

如何递归地运行树，创建节点，调用函数，并深入潜水？

2 个答案: