回溯算法 - 转非递归

回溯法是对解空间的深度优先搜索

void backtrack(int t) {

  if (t>n) output(x);

  else 

    for (int i=f(n,t);i<=g(n,t);i++){

      x[t] = h(i);

      if (constraints(t) && bound(t)) backtrack(t+1);

    }

}

t递归深度， 当前扩展节点在解空间的深度

n解空间树的高度,t>n表示搜索到了树节点

f(n,t),g(n,t)表示在当前扩展节点搜索的子树的起始编号和终止编号

h(i)表示在当前节点处的值

机器人从(0,0)到(x,y), 只能向右或向下,递归算法如下

public static void f(int x, int y, List<Node> path) {
path.add(new Node(x, y));
System.out.println("x: " + x + ", y: " + y);
if (x == 0 && y == 0) {
for (int i = path.size() - 1; i >= 0; i--) {
Node e = path.get(i);
System.out.print("(" + e.x + "," + e.y + ") ->");
}
System.out.println("");
}


if (x < 0 || y < 0) {
return;
}
if (x > 0) {
f(x - 1, y, path);
System.out.println("退回左" + "x: " + x + ", y: " + y);

}


if (y > 0) {
f(x, y - 1, path);
System.out.println("退回右" + "x: " + x + ", y: " + y);
}
path.remove(path.size() - 1);

}

机器人从(0,0)到(x,y), 只能向右或向下,非递归算法如下

public static void step(Node e) {
Stack<Node> ns = new Stack<Node>();
Stack<Integer> is = new Stack<Integer>();
ns.push(e);
is.push(goleft);
while (!ns.empty()) {
Node n = ns.peek();
int operator = is.peek();
if (operator == goleft) {
is.pop();
is.push(goright);
if (n.x - 1 >= 0) {
ns.push(new Node(n.x -1, n.y));
is.push(goleft);
}
} else if (operator == goright) {
is.pop();
is.push(goback);
if (n.y - 1 >= 0) {
ns.push(new Node(n.x, n.y - 1));
is.push(goleft);
}
} else if (operator == goback) {
if (n.x == 0 && n.y == 0) {
Iterator it  = ns.iterator();
while (it.hasNext()) {
Node o = (Node)it.next();
System.out.print("(" + o.x + "," + o.y + ") ->");
}
System.out.println("");
}
is.pop();
ns.pop();
}
}
}