2

I came across this problem on one of the websites.

Requirement:

Need to propose the algorithm and caclulate the time complexity of Towers of Hanoi problem if two auxilary rods are given instead of one.

My Attempt:

Original Towers of Hanoi:

T(N)= T(N-1) // Moving N-1 disks from Source to Auxilary 
    + 1      // Moving Nth disk from Source to Destination  
    + T(N-1) // Moving N-1 disks from Auxilary to Destination

     T(N) = 2*T(N-1) + 1 

            = O(2 power N )   // exponential.

In the current problem since we have two auxialry rods

`

     T(N) =

          T(N/2)  // Moving top N/2 from Source to Aux1

          + T(N/2)  // Moving the remaining N/2 from Source to Destination using Aux2.

           + T(N/2)  // Moving N/2 from Aux1 to Destination.

                T(N) = 3*T(N/2) 
                =O( 3 power log N base 2 ) 
                = O( N power log 3 base 2 )  // less than quadartic.

But I am not very sure about this since I am not calculation time as T(N/2) for moving top N/2 to Aux1 and also for moving botton N/2 from Source to Destination using Aux2.

Why I think it is incorrect is because in first case while moving top (N/2) we can play with three rods : Destiation,Aux1 & Aux2 But while moving the bottom (N/2) we can play only with two rods Destination,Aux2

So I think there should even better approach for this problem.

Maheedhar Pamuru
  • 139
  • 1
  • 1
  • 7

2 Answers2

1

Here's a simple memoized recursive function in Python that uses the Frame–Stewart algorithm to find the minimum number of moves. According to the Wikipedia article linked above, this algorithm is proven to be optimal for 4 pegs and up to 30 disks, and it's believed to be optimal for all combinations of n disks and r pegs (but not proven to be so). Its possible my implementation could be optimized a bit, but it's fast enough for reasonable n and r values.

def hanoi(n, r, memo={}):    # deliberately using a mutable default argument here
    """Return the number of steps required to move n disks using a total of r pegs."""
    if n == 1:               # base case
        return 1
    if r <= 2:               # impossible cases
        return float("inf")
    if (n,r) not in memo:
        memo[n, r] = min(hanoi(k, r)*2 + hanoi(n-k, r-1)   # recursive calls
                         for k in range(1, n))
    return memo[n, r]
Blckknght
  • 100,903
  • 11
  • 120
  • 169
0

Base case -

  1. If there are no rings, then return.
  2. If there is a single ring, directly transfer to destination.
  3. Transfer n-2 to 2nd auxiliary tower. First recursion
  4. Transfer second largest ring to 1st auxiliary tower and then transfer largest ring to the destination tower. Then, transfer second largest ring destination tower. The 3 print statements
  5. Transfer n-2 to destination tower. Second Recursion

The idea behind 4th step is that there is no faster approach to transfer stack of size 2 to destination, no matter the number of auxiliary towers.

// Number of rings, from tower, destination tower, 1st auxiliary tower and 2nd auxiliary tower.
void hanoi(int rings, int from, int to, int aux1, int aux2){
    if(rings==0)
        return;
    if(rings==1){
        cout<<from<<" to "<<to<<endl;ct++;
        return;
    }
    hanoi(rings-2, from, aux2, aux1, to);
    cout<<from<<" to "<<aux1<<endl;
    cout<<from<<" to "<<to<<endl;
    cout<<aux1<<" to "<<to<<endl;
    ct+=3;
    hanoi(rings-2,aux2, to, from, aux1);
}

int main(){
    int i,n,j,k,l,m;
    cin>>n;
    hanoi(n,0,1,2,3);
    cout<<ct<<endl;
}
Pratik
  • 1
  • 1