河内之塔：找到第n个配置

Question

I want to find the n-th configuration in the solution of the Towers of Hanoi problem given the number of discs and the move's number.

The following code finds the n-th move using tail recursion:

  public static String N_th_Move(int k_discs, int move){
        return HanoiRec(k_discs, move, "A", "B", "C");
    }

    private static String HanoiRec(int k_discs, int move, String rod_a, String rod_b, String rod_c) {
        int max_n_moves = (int) (Math.pow(2, k_discs) - 1); 
        int bound =(int) Math.pow(2, k_discs - 1);
        if(move > max_n_moves){
            return "Not valid";
        } else if(move == bound ){
            return rod_a + " -> " + rod_b;
        } else if(move < bound){
            return HanoiRec(k_discs-1, move , rod_a, rod_c, rod_b);
        } else {
            return HanoiRec(k_discs-1, move - bound, rod_c, rod_b, rod_a);
        }
    }

How to find the n-th configuration using the same approach?

Eg:

N_th_configuation(3, 4) #{rod_a: 0, rod_b: 1, rod_c: 2}

ADDED: The binary tree for 3 discs (following the above code):

                                (0  1  2)
                               /         \
                        (1 1 1)           (0 2 1)
                       /       \         /       \
                    (2 1 0)  (1 0 2)  (1 1 1)  (0 3 0)

Where the first number is the number of discs on rod_a, the second on rod_b and the third on rod_c. The bottom-left leaf is the configuration after the first move and the bottom-right leaf is the configuration after the last move. I don't find out the relation between all configurations.

Answer 1

The canonical solution for ToH is to alternate two types of moves:

1. Move the smallest disc to the next rod (with wraparound back to the initial rod)
2. Make the one legal move that does not include the smallest disc.

wlog (without loss of generality), let's assume that the smallest disc always moves to the next higher-numbered rod (labeled 0, 1, 2).

One result of this algorithm is that odd-numbered discs move higher; even-numbered discs move lower.

Another result is that you can independently determine the disc for any given move number: it's the lowest-value 1 bit in the binary representation of that number. For instance, for the 3-disc problem:

Move  binary disc
  1     001    1
  2     010    2
  3     011    1
  4     100    3
  5     101    1
  6     110    2
  7     111    1

To find the position matching any move N :

1. Divide the binaries into separate digits.
2. Mask off all bit the right-most 1 bit in each.
3. Add the columns.
4. Negate the even-numbered columns (to show that the discs move in the opposite direction.
5. Reduce the totals modulus 3.

The result is a list of columns on which each disc rests.