JAVA   20
Hanoi
Guest on 20th September 2023 12:21:32 AM


  1.  
  2. import java.awt.*;
  3.  
  4. public class Hanoi
  5. {
  6.         private int n;
  7.         private int target;
  8.         private int counter;
  9.         private int[] ptr;
  10.         private int[][] tower;
  11.         private Point[] loc;
  12.         private String[] args;
  13.  
  14.         public static void main(String[] args)
  15.         {
  16.                 Hanoi h = new Hanoi(args);
  17.                 h.solve();
  18.         }
  19.  
  20.         Hanoi(String[] args)
  21.         {
  22.                 this.args = args;
  23.  
  24.         public void solve()
  25.         {
  26.                 init();
  27.                 if(parse(args))
  28.                 {
  29.                         startHanoi();
  30.                 }
  31.                 else
  32.                 {
  33.                         System.out.printf("args should have two strings.\n");
  34.                 }
  35.         }
  36.  
  37.         private void init()
  38.         {
  39.                 tower = new int[3][];
  40.                 ptr = new int[3];
  41.                 counter = 0;
  42.         }
  43.  
  44.         private boolean parse(String[] args)
  45.         {
  46.                 int i;
  47.                 char ch;
  48.                 if(args.length < 2)
  49.                 {
  50.                         return false;
  51.                 }
  52.                 n = args[0].length();
  53.                 target = args[1].charAt(0) - 65;
  54.                 for(i=0; i<3; i++)
  55.                 {
  56.                         tower[i] = new int[n];
  57.                 }
  58.                 loc = new Point[n];
  59.                 for(i=n-1; i>=0; i--)
  60.                 {
  61.                         ch = args[0].charAt(i);
  62.                         tower[ch-65][ptr[ch-65]++] = i;
  63.                         loc[i] = new Point(ch-65, ptr[ch-65]-1);
  64.                 }
  65.                 return true;
  66.         }
  67.  
  68.         private void startHanoi()
  69.         {
  70.                 int i;
  71.                 printResult();
  72.                 for(i=1; i<n; i++)
  73.                 {
  74.                         move(i-1, loc[i-1].x, loc[i].x);
  75.                 }
  76.                 move(n-1, loc[n-1].x, target);
  77.         }
  78.  
  79.         private void move(int dish, int now, int targ)
  80.         {
  81.                 int tmp;
  82.                 if(now == targ)
  83.                 {
  84.                         return;
  85.                 }
  86.                 tmp = 3 - now - targ;
  87.                 if(dish > 0)
  88.                 {
  89.                         move(dish-1, now, tmp);
  90.                 }
  91.                 loc[dish] = new Point(targ, ptr[targ]);
  92.                 ptr[now]--;
  93.                 tower[targ][ptr[targ]++] = dish;
  94.                 printResult();
  95.                 if(dish > 0)
  96.                 {
  97.                         move(dish-1, tmp, targ);
  98.                 }
  99.         }
  100.  
  101.         private void printResult()
  102.         {
  103.                 int i, j;
  104.                 System.out.printf("%4d:", ++counter);
  105.                 for(i=0; i<3; i++)
  106.                 {
  107.                         System.out.print(" [");
  108.                         for(j=0; j<ptr[i]; j++)
  109.                         {
  110.                                 System.out.printf("%d", tower[i][j]+1);
  111.                         }
  112.                         for(j=ptr[i]; j<n; j++)
  113.                         {
  114.                                 System.out.print(" ");
  115.                         }
  116.                         System.out.print("]");
  117.                 }
  118.                 System.out.printf("\n");
  119.         }
  120. }
Raw Paste

Login or Register to edit or fork this paste. It's free.