Backtracking prorblem and I don't know if my plan to solve it is correct

Question

I am practicing a backtracking problem and here is the problem description: https://practiceit.cs.washington.edu/problem/view/cs2/sections/recursivebacktracking/travel

Write a method travel that accepts integers x and y as parameters and uses recursive backtracking to print all solutions for traveling in the 2-D plane from (0, 0) to (x, y) by repeatedly using one of three moves:

East (E): move right 1 (increase x) North (N): move up 1 (increase y) Northeast (NE): move up 1 and right 1 (increase both x and y).

Here is what I got: I get it to work on one path but I am not sure how to make it go explore all other possible paths. I am thinking my base case design is wrong but I am not sure. I just want to know what I should fix first, is the base case or my entire concept is wrong.

public class PracticeRecordCode {
    public static void main(String[] args) {
        travel(1, 2);
    }
    public static String travel(int x, int y){
        List<String> allpath = new ArrayList<String>();

        String eachpath = "";

        return explore(0, 0, x, y, eachpath, allpath);
    }

    public static String explore(int x, int y, int des_x, int dest_y, String eachPath, List<String> allpath) {
        //Base case
        if(x == des_x && y== dest_y) {
                String result = "";
                if(isRepeated(eachPath, allpath)){
                    allpath.add(eachPath);
                    eachPath = "";
                }
            // Print all content from allpath
                for (String path : allpath) {
                    result += path + "\n";
                    System.out.println(path);
                }
                return result;
        } else {

            if(x == des_x && y != dest_y){
                eachPath += "N ";
                if(!allpath.contains(eachPath)) {
                    allpath.add(eachPath);
                }
                explore(x, y+1, des_x, dest_y, eachPath, allpath);
            } else if(x != des_x && y == dest_y) {
                eachPath += "E ";
                allpath.add(eachPath);
                explore(x + 1, y, des_x, dest_y, eachPath, allpath);
            } else {
                eachPath += "NE ";
                allpath.add(eachPath);
                explore(x + 1, y+1, des_x, dest_y, eachPath, allpath);
            }
        }
        return "";
    }

    // Check if this path has been done already
    public static boolean isRepeated(String path, List<String> allpath){
        return allpath.contains(path);
    }

}

score 0 · Answer 1 · answered Jan 22 '21 at 21:19

You can try my code. Hope it may give your solution->

public static void main(String[] args) {
    baktracking(new boolean[5][3], 0, 0, 2, 2, "");
}

static void baktracking(boolean m[][], int x, int y, int dx, int dy, String ans) {
    if (x == dx && y == dy) {
        System.out.println(ans);
        return;
    }
    if (x < 0 || y < 0 || x >= m.length || y >= m[0].length) {
        return;
    }
    m[x][y] = true;
    baktracking(m, x, y +1, dx, dy, ans + "E" + " ");
    baktracking(m, x + 1, y, dx, dy, ans + "N" + " ");
    baktracking(m, x + 1, y + 1, dx, dy, ans + "NE" + " ");
    m[x][y] = false;
}

I think it is better if I know how to improve it but I appreciate the code, I can get some idea from that. — ChienChih Huang, Jan 22 '21 at 22:17

bob tang · Accepted Answer · 2021-01-22T22:48:29.387

we can do some improvements to your explore method, as there is some defect in your implementation. There are two exit conditions: 1. when you reach the destination, which is a valid path and we can save it into your final result. 2. you reach over the destination (x>des_x || y>dest_y), which means that's an invalid path, and we don't have to keep exploring any more. And otherwise, you have 3 options to keep exploring: E, N, or NE. And as each direction is unique, you don't have to worry about duplicate. when all possible explore is done, your allpath list will have all the valid paths added. And you can either return the list or print it. Based on this, your code can be much simpler like this:

import java.util.ArrayList;
import java.util.List;

public class PracticeRecordCode {

    public static void main(String[] args) {
        travel(2, 2);
    }
    public static void travel(int x, int y){
        List<String> allpath = new ArrayList<String>();

        explore(0, 0, x, y, "", allpath);

        // Print all content from allpath
        for (String path : allpath) {
            System.out.println(path);
        }

    }

    public static void explore(int x, int y, int des_x, int dest_y, String eachPath, List<String> allpath) {
        //Base case
        if(x == des_x && y == dest_y) {
            allpath.add(eachPath);
            return;
        }
        if(x>des_x || y>dest_y)
            return;
        explore(x + 1, y, des_x, dest_y, eachPath + "E ", allpath);

        explore(x, y+1, des_x, dest_y, eachPath + "N ", allpath);

        explore(x + 1, y+1, des_x, dest_y, eachPath + "NE ", allpath);
    }
}

Thanks, I think what confused me the most is the part of I put all explore recursions at if-else statements and I did not change my eachPath during each recursion so it wouldn't update itself. — ChienChih Huang, Jan 23 '21 at 00:28
Plus I did screw up the base case, there are supposed to be at least two conditions. I think that's the main reason why I couldn't understand it earlier. — ChienChih Huang, Jan 23 '21 at 00:36
Yes, your if-else statements logic is not correct: if(x == des_x && y != dest_y), which means it only moves 'E'ast when x == des_x, but actually, it can moves when x — bob tang, Jan 23 '21 at 01:04

Backtracking prorblem and I don't know if my plan to solve it is correct

2 Answers2