JAVA - 四柱汉诺塔最优移动次序展示

最新推荐文章于 2021-03-27 12:12:30 发布
置顶 最新推荐文章于 2021-03-27 12:12:30 发布
阅读量1.4k 收藏 2
点赞数 5
分类专栏： 小游戏 java 算法 文章标签： 四柱汉诺塔
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40285036/article/details/86534637
版权
算法 同时被 3 个专栏收录
29 篇文章 1 订阅
订阅专栏
小游戏
4 篇文章 0 订阅
订阅专栏
java
1 篇文章 0 订阅
订阅专栏

本文是初学JAVA的自己做的一个小程序，关于面向对象的思想掌握的还不是很好，还没完全从c++过渡过来，尽情各位看官大佬批评指正。（中间汉诺塔的英文单词写错了//尴尬?）

各个类的功能和函数注释的很详细了就不详解了。如果有想要学习算法【获得移动的最少步数】就只看方向类就可以。

各类源代码下载链接：https://download.csdn.net/download/qq_40285036/10841684

运行演示：
在这里插入图片描述
主类

/*
 * 主函数
 * 
 * 包含了各个类之间的逻辑控制
 */
package Hanio;

import java.awt.Color;
import java.awt.Font;
import java.util.*;
import javax.swing.*;

import Hanio.Pillars;
import Hanio.Direction;
import Hanio.Direction.Step;
import Hanio.MyPillar;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.print.Book;

public class MainHanio extends JFrame {
	
	public static int PlateN = 20;
	
	// 主窗口的大小
	public static int MainFrameWidth = 1800;
	public static int MainFrameHeight = 900;
	// 柱子的大小
	public static int PillarWidth = 2;
	public static int PillarHeight = 500;
	// 柱子的位置
	public static int PillarLocationAX = 200;
	public static int PillarLocationAY = 200;
	public static int PillarLocationBX = 600;
	public static int PillarLocationBY = 200;
	public static int PillarLocationCX = 1000;
	public static int PillarLocationCY = 200;
	public static int PillarLocationDX = 1400;
	public static int PillarLocationDY = 200;
	// 盘子的大小
	public static int PlateHeight = 10;
	// 主窗口
	public static JFrame mainframe;
	// 四个柱子
	public static MyPillar pillarA;
	public static MyPillar pillarB;
	public static MyPillar pillarC;
	public static MyPillar pillarD;
	
	// 保存当前所有的盘子
	public static Plate[] allPlate;
	// 最有移动次序
	public static List<Step> mySteps;
	// 当前移动到了第几步
	public static int pstep = 0;
	
	// 为了方便逻辑控制 设置的一些全局变量
	public static int FromX,FromY,EndX,EndY;
	public static Plate CurrentPlate;
	// 字体的格式，出现的所有字体都使用的这个格式
	public static Font allFont = new Font("宋体",Font.BOLD,20);
	// 文本框
	public static JTextField plateTextField;
	// 更新按钮和下一步按钮
	public static JButton updataButton;
	public static JButton nextStepButton;
	
	// windows 窗口动作的监听类
	static class windowsEvent implements WindowListener 
	{

		@Override
		public void windowActivated(WindowEvent arg0) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void windowClosed(WindowEvent arg0) {
			// TODO Auto-generated method stub
		}

		@Override
		public void windowClosing(WindowEvent arg0) {
			// TODO Auto-generated method stub
			System.out.println("this is be closed");
			mainframe.dispose();
			System.gc();
		}

		@Override
		public void windowDeactivated(WindowEvent arg0) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void windowDeiconified(WindowEvent arg0) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void windowIconified(WindowEvent arg0) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void windowOpened(WindowEvent arg0) {
			// TODO Auto-generated method stub
			
		}
		
	}
	
	// 盘子移动，更新窗口的线程类
	static class MyThread extends Thread
	{
		public void run()
		{
			int fx = FromX, fy = FromY;
			int ex = EndX, ey = EndY;
			Plate cur = CurrentPlate;
			
			while(fx != ex || fy != ey)
			{
				int tx = (ex - fx);if(tx != 0) tx /= Math.abs(ex - fx);
				int ty = (ey - fy);if(ty != 0) ty /= Math.abs(ey - fy);
				fx += tx;fy += ty;
				cur.setLocation(fx, fy);
				mainframe.repaint();
				
				try
				{
					//Thread.sleep(1);
				}
				catch(Exception e)
				{
					System.out.println("Thread Exception!");
				}
			
			}
			
		}
	}

	// 键盘监听类
	static class MyKey implements KeyListener
	{

		@Override
		public void keyPressed(KeyEvent e) {
			// TODO Auto-generated method stub
			
			if(pstep == mySteps.size())
			{
				System.out.println("移动完成!!");
				return;
			}
			movePlate(mySteps.get(pstep).begin, mySteps.get(pstep).end);
			pstep++;
		}

		@Override
		public void keyReleased(KeyEvent e) {
			// TODO Auto-generated method stub
			
		}

		@Override
		public void keyTyped(KeyEvent e) {
			// TODO Auto-generated method stub
			
		}
		
	}

	// 制作主窗口
	public static void createFrame(int w,int h)
	{
		JPanel panel = new JPanel();
		panel.setBackground(Color.DARK_GRAY);
		
		mainframe = new JFrame();
		
		mainframe.addKeyListener(new MyKey());
		mainframe.setSize(w, h);
		mainframe.setTitle("Hanio");
		mainframe.setBackground(Color.DARK_GRAY);
		mainframe.getLayeredPane().add(panel, Integer.MIN_VALUE);
		mainframe.setVisible(true);
	}

	// 制作盘子
	public static void createPlate(int n)
	{
		allPlate = new Plate[n];
		for(int i = 1;i <= n;i++)
		{
			int w = 20 * (n - i) + 10;
			int h = 10;
			int x = PillarLocationAX - w / 2;
			int y = PillarLocationAY + PillarHeight - i * 10;
			allPlate[i - 1] = new Plate(w, h, x, y);
			pillarA.addPlate(allPlate[i - 1]);
			mainframe.getLayeredPane().add(allPlate[i - 1], new Integer(2));
		}
	}
	
	// 制作柱子
	public static void createPillars()
	{
		pillarA = new MyPillar(PillarWidth,PillarHeight);
		pillarA.setLocation(PillarLocationAX, PillarLocationAY);
		pillarB = new MyPillar(PillarWidth,PillarHeight);
		pillarB.setLocation(PillarLocationBX, PillarLocationBY);
		pillarC = new MyPillar(PillarWidth,PillarHeight);
		pillarC.setLocation(PillarLocationCX, PillarLocationCY);
		pillarD = new MyPillar(PillarWidth,PillarHeight);
		pillarD.setLocation(PillarLocationDX, PillarLocationDY);
		
		pillarA.setVisible(true);
		pillarB.setVisible(true);
		pillarC.setVisible(true);
		pillarD.setVisible(true);
		
		mainframe.getLayeredPane().add(pillarA, new Integer(3));
		mainframe.getLayeredPane().add(pillarB, new Integer(3));
		mainframe.getLayeredPane().add(pillarC, new Integer(3));
		mainframe.getLayeredPane().add(pillarD, new Integer(3));
		
	}
	
	// 移动方向和当前柱子的映射
	public static MyPillar choosePillar(Pillars A)
	{
		switch(A)
		{
		case A:return pillarA;
		case B:return pillarB;
		case C:return pillarC;
		case D:return pillarD;
		
		}
		return pillarA;
	}

	// 利用多线程更新盘子
	public static void movePlate(Pillars A,Pillars B)
	{
		MyPillar from = choosePillar(A), to = choosePillar(B);
		Plate plate = from.getTop();
		
		int ex = to.getLocation().x - plate.getWidth() / 2;
		int ey = to.getLocation().y + to.getHeight() - 10 * (to.getPlateCouner() + 1);
		System.out.println(pillarB.getPlateCouner());
		System.out.println(pillarC.getPlateCouner());
		FromX = plate.getLocation().x;
		FromY = plate.getLocation().y;
		EndX = ex;
		EndY = ey;
		
		CurrentPlate = plate;
		to.addPlate(plate);
		from.removePlate();
		
		new MyThread().start();
	}
	
	// 制作标签
	public static void createLabel(int x,int y,int w,int h, String text)
	{
		JLabel plateCounter = new JLabel();
		plateCounter.setSize(w,h);
		plateCounter.setFocusable(false);
		plateCounter.setLocation(x,y);
		plateCounter.setText(text);
		plateCounter.setVisible(true);
		plateCounter.setFont(allFont);
		plateCounter.addFocusListener(new FocusListener(){
            @Override
            public void focusLost(FocusEvent e) {  
                //失去焦点执行的代码 
            	System.out.println("TextField 失去焦点");
            }
            @Override
             public void focusGained(FocusEvent e) {
                //获得焦点执行的代码 
            }
        });
		
		mainframe.getLayeredPane().add(plateCounter, Integer.MIN_VALUE);
		mainframe.repaint();
	}
	
	// 制作输入框
	public static void createTextBox(int x,int y,int w,int h)
	{
		plateTextField = new JTextField();
		plateTextField.setFont(allFont);
		plateTextField.setText("20");
		plateTextField.setLocation(x,y);
		plateTextField.setSize(w,h);
		plateTextField.setVisible(true);
		
		mainframe.getLayeredPane().add(plateTextField, Integer.MIN_VALUE);
	}
	
	// 制作按钮
	public static void createUpdataButton(int x,int y,int w,int h,String text)
	{
		updataButton = new JButton();
		updataButton.setText(text);
		updataButton.setFocusPainted(false);
		updataButton.setFocusable(false);
		updataButton.setSize(w,h);
		updataButton.setLocation(x,y);
		updataButton.setFont(allFont);
		updataButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e)
			{
				if(plateTextField.getText().isEmpty())
				{
					plateTextField.setText("不能为空!");
					return;
				}
				String str = plateTextField.getText();
				for(int i = 0;i < str.length();i++)
				{
					if(str.charAt(i) < '0' || str.charAt(i) > '9')
					{
						plateTextField.setText("数字不合法");
						return;
					}
				}
				resetFrame();
				
				
			
				//plateTextField.setEditable(false);
				//plateTextField.setEditable(true);
			}
		});
		updataButton.setVisible(true);
		
		mainframe.getLayeredPane().add(updataButton, Integer.MIN_VALUE);
	}
	
	// 制作按钮
	public static void createNextStepButton(int x,int y,int w,int h,String text) {
		nextStepButton = new JButton();
		nextStepButton.setLocation(x,y);
		nextStepButton.setSize(w,h);
		nextStepButton.setText(text);
		//nextStepButton.addActionListener(new ActionListener() {
		//	public void actionPerformed(ActionEvent e)
		//	{
		//		if(pstep == mySteps.size())
		//		{
		//			System.out.println("移动完成!!");
		//			return;
		//		}
		//		movePlate(mySteps.get(pstep).begin, mySteps.get(pstep).end);
		//		pstep++;
		//	}
		//});
		nextStepButton.setFont(allFont);
		nextStepButton.setFocusable(true);
		nextStepButton.addKeyListener(new MyKey());
		nextStepButton.setVisible(true);
		
		mainframe.getLayeredPane().add(nextStepButton, Integer.MIN_VALUE);
		
	}
	
	// 释放当前资源
	public static void disposeAll()
	{
		mySteps.clear();
		for(int i = 0;i < PlateN;i++)
			mainframe.getLayeredPane().remove(allPlate[i]);
		mainframe.getLayeredPane().remove(pillarA);
		mainframe.getLayeredPane().remove(pillarB);
		mainframe.getLayeredPane().remove(pillarC);
		mainframe.getLayeredPane().remove(pillarD);
		mainframe.repaint();
	}
	
	// 重置窗口
	public static void resetFrame()
	{
		disposeAll();
		pstep = 0;
		PlateN = Integer.parseInt(plateTextField.getText());	
		Direction dir = new Direction(PlateN);
		dir.getOptmalMove();
		dir.getMoveSteps4(PlateN, Pillars.A, Pillars.B, Pillars.C, Pillars.D);
		mySteps = dir.getSteps();
		createPillars();
		createPlate(PlateN);
	}
	
	public static void main(String[] args)
	{
		//得到最有移动次序
		Direction dir = new Direction(PlateN);
		dir.getOptmalMove();
		dir.getMoveSteps4(PlateN, Pillars.A, Pillars.B, Pillars.C, Pillars.D);
		mySteps = dir.getSteps();
		
		//初始化前台
		createFrame(MainFrameWidth, MainFrameHeight);
		createPillars();
		createPlate(PlateN);
		createLabel(0,720,180,30,"请输入盘子数量:");
		createTextBox(180, 720, 70, 30);
		createUpdataButton(250,720,100, 30, "重置");
		createNextStepButton(350,720,100,30,"下一步");
		
		// 增加windows的监听事件
		mainframe.addWindowListener(new windowsEvent());
		mainframe.repaint();
		
		
	}
	

}

方向类

/*方向移动判断类
 * 四柱汉诺塔的移动采用的是最少移动次数
 * 大概思路是先用动态规划的思想求出最优值
 * 在递归寻找最优解也就是最优移动次序
 * 
 * 下面的程序还包含了三柱汉诺塔的移动
 */

package Hanio;

import Hanio.Pillars;

import java.awt.Point;
import java.util.*;


public class Direction {
	
	// 记录移动的方向 从begin柱子到end柱子
	public static class Step{
		public Pillars begin;
		public Pillars end;
		
		public Step(Pillars a,Pillars b)
		{
			begin = a;end = b;
		}
	}
	
	// 有n个盘子
	public static int n;
	// dp vis 动态规划所用
	public static int[] dp;
	public static int[] vis;
	// 记录最优移动次序
	public static List<Step> Steps = new ArrayList<Step>();
	
	// 初始化  tmpn 是盘子的个数
	public Direction(int tmpn)
	{
		n = tmpn;
		dp = new int[n + 2];
		vis = new int[n + 2];
	}
	
	// 动态规划求解最优值
	public static void getOptmalMove()
	{
		dp[1] = 1;
		dp[2] = 3;
		for(int i = 3;i <= n;i++)
		{
			dp[i] = 0x3f3f3f3f;
			for(int k = 1;k < i;k++)
			{
				// 最优子结构
				int tmp = (int) (2 * dp[k] + Math.pow(2,  i - k) - 1);
				if (tmp < dp[i])
				{
					dp[i] = tmp;
					vis[i] = k;
				}
			}
			System.out.println(dp[i]);
		}
		
	}

	// 移动一个盘子， 保存移动方向
	public static void moveOneStep(Pillars A,Pillars B)
	{
		Steps.add(new Step(A, B));
	}
	
	// 得到三柱汉诺塔的移动方向
	public static void getMoveSteps3(int k, Pillars A,Pillars B,Pillars C)
	{
		if(k == 1)
		{
			moveOneStep(A, C);
			return;
		}
		getMoveSteps3(k - 1,A, C, B);
		moveOneStep(A, C);
		getMoveSteps3(k - 1,B, A, C);
	}

	// 得到四柱汉诺塔的移动方向
	public static void getMoveSteps4(int k,Pillars A,Pillars B,Pillars C,Pillars D)
	{
		if(k == 1) {
			moveOneStep(A, D);
			return;
		}
		if(k == 2)
		{
			moveOneStep(A, B);
			moveOneStep(A, D);
			moveOneStep(B, D);
			return;
		}
		getMoveSteps4(vis[k], A, C, D, B);
		getMoveSteps3(k - vis[k], A, C, D);
		getMoveSteps4(vis[k], B, A, C, D);
	}
	
	// 返回移动次序
	public static List<Step> getSteps()
	{
		return Steps;
	}
	
	// 测试函数
	public void printSteps()
	{
		for(Step step : Steps)
		{
			System.out.println(step.begin + "->" + step.end);
		}
	}
	
}

盘子类

/*
 * 盘子类
 * 记录每个盘子的状态
 * 例如：在哪个柱子，盘子的颜色，大小
 */

package Hanio;


import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;


import javax.swing.*;

public  class Plate extends JPanel{
	
	// 为了产生随机颜色
	public static Color[] color = {Color.black,Color.BLUE, Color.decode("#800080"),Color.GREEN,Color.pink
			,Color.MAGENTA,Color.RED,Color.CYAN,Color.decode("#4B0082"),Color.ORANGE};
	
	
	public void mySetSize(int w,int h)
	{
		
		this.setSize(w, h);
		this.setVisible(true);
	}
	
	public void mySetLocation(int x,int y)
	{
		this.setLocation(x, y);
	}
	
	public void myPaint() {
	}
	
	public Plate() {
		
	}
	
	// 初始化
	public Plate(int w,int h,int x,int y)
	{
		Random rand = new Random();
		// 生成随机颜色
		this.setBackground(color[rand.nextInt(10)]);
		this.setLocation(x, y);
		this.setSize(w, h);
		this.setVisible(true);
	}
	
	
	
}

柱子类

/*
 * 柱子类
 * 主要是记录当前柱子上的盘子 
 */
package Hanio;

import Hanio.Pillars;
import Hanio.Plate;

import java.awt.Color;
import java.util.*;
import javax.swing.*;

public class MyPillar extends JPanel {
	
	// 记录当前柱子上的盘子
	public List<Plate> pillars = new ArrayList<Plate>();;	
	public MyPillar() {}
	public MyPillar(int w, int h) {
		this.setSize(w, h);
		this.setBackground(Color.BLUE);
		this.setVisible(true);
	}
	
	// 增加一个盘子
	public void addPlate(Plate plate)
	{
		pillars.add(plate);
	}
	
	public void removePlate()
	{
		if(pillars.size() == 0)
		{
			System.out.println("No Plate!");
			return;
		}
		pillars.remove(pillars.size() - 1);
	}
	
	// 得到柱子上的最上面的一个盘子
	public Plate getTop()
	{
		return pillars.get(pillars.size() - 1);
	}
	
	// 得到柱子上盘子的个数
	public int getPlateCouner()
	{
		return pillars.size();
	}
	
}

柱子的枚举

package Hanio;

// 四个柱子的枚举  ，方便传参
public enum Pillars {
	A,B,C,D
}
特立独行的猪鸭
关注
专栏目录
四柱汉诺塔演示程序-动态规划求解最优移动次数-java前台展示
12-10
四柱汉诺塔的演示程序，程序使用动态规划的方法求解了最优移动次数，java制作的前台界面进行移动展示的。具体动态规划的代码有c++版本的可以参考这篇博客https://blog.csdn.net/qq_40285036/article/details/84799426
hdu 1207 汉诺塔II (四柱汉诺塔)
laoda扯一扯
08-21 6458
思路是借鉴网上一大牛的，写的很完美了，所以一句没改，代码是自己敲的，C语言版 变体汉诺塔     问题描述：在经典汉诺塔的基础上加一个条件，即，如果再加一根柱子（即现在有四根柱子a,b,c,d)，计算将n个盘从第一根柱子(a)全部移到最后一根柱子(d)上所需的最少步数，当然，也不能够出现大的盘子放在小的盘子上面。注：1 分析：设F[n]为所求的最小步数，显然，当n=1时，F[n]=1;当n=
汉诺塔
李佩爽的博客
04-04 390
提交文件：hanoi.exe 输入文件：hanoi.in 输出文件：hanoi.out 题目描述： 你对经典的hanoi塔问题一定已经很熟悉了。有三根柱子，n个大小不一的圆盘，要求大盘不能压在小盘上，初始时n个圆盘都在第一根柱子上，最少要多少步才能挪到最后一根柱子上？ 现在我们来将hanoi塔扩展一下，由三根柱子扩展到四根柱子，其余规则不变。例如，3个圆盘，四根柱子A到D，初始时圆盘都A
汉诺塔四根柱子java,奇怪的汉诺塔
weixin_39957318的博客
03-27 224
首先打表出只有三根柱子时1~12个圆盘所需的次数，思路是这样的，对于三根柱子，首先将前i-1个圆盘移动到某一根柱子，然后将最后一个圆盘移动到一根柱子，最后再将剩下的i-1个圆盘移动到一根柱子，所以three[i] = three[i - 1] + 1 + three[i - 1]对于四根柱子来说，枚举前j个圆盘，首先将前j个圆盘移动到四根柱子种的某一根，次数是four[j]，然后将剩下的i-j个圆...
四柱汉诺塔问题
qq_30708623的博客
04-14 1146
Strange Towers of Hanoi nowcoder 首先考虑三柱汉诺： 将 k-1 个盘子移动到B,最大的一个盘子移动到C，再将k-1个盘子移动到C f(k)=2∗f(k−1)+1 f(k) = 2*f(k-1)+1 f(k)=2∗f(k−1)+1 当 k 确定时 f ( k ) 的值不会变。 四柱汉诺塔 四汉诺塔的最优解是将所有盘子移动到D次数最少的情况。...
c代码-四柱汉诺塔
07-14
四柱汉诺塔（Hanoi Tower）是一种经典的递归问题，源自印度的传说，它涉及到在三根柱子上移动盘子的过程。在这个问题中，我们有若干个大小不一的圆盘，最初都放在第一根柱子（A柱）上，按照从大到小的顺序自下而上...
四柱汉诺塔_四柱汉诺塔_
09-29
四柱汉诺塔是一种在传统三柱汉诺塔游戏基础上扩展的版本，它引入了第四根柱子，增加了游戏的复杂性和挑战性。在经典的三柱汉诺塔游戏中，目标是将所有盘子从第一根柱子（源柱）移动到第三根柱子（目标柱），同时遵循...
四柱HanoiTower----是甜蜜还是烦恼
hyshucom
10-16 426
我想很多人第一次学习递归的时候，老师或者书本上可能会举汉诺塔的例子。 但是今天，我们讨论的重点不是简单的汉诺塔算法，而是三柱汉诺塔的延伸。先来看看经典的三柱汉诺塔。 一、三柱汉诺塔（Hanoi_Three）： 我想大家对于三柱汉诺塔的理解以及算法的实现应该是很熟练了。 我在这里简单的过一遍三柱汉诺塔的算法思想： 有A、B、C三根柱子，A柱上有n个盘子，现在需要将A上所有的盘子转移到C...
Java实现汉诺塔移动过程
z_xindong的博客
09-14 1065
import java.util.*; public class Main { public static void Show(int q,char w,char e) { System.out.printf("Move disk %d from %c to %c\n",q, w,e); } public static void Move(int n,char a,char...
四柱
weixin_30346033的博客
03-23 4151
姓名：　　出生地：　　排盘方式：普通方式排盘 公历：1986年3月20日7时52分　　农历：丙寅年[炉中火]二月十一日 惊蛰：1986年03月06日05时12分　　元亨利贞网四柱八字在线排盘系统　 清明：1986年04月05日10时02分　　　　http://bbs.china95.net 起运：命主于出生后5年4个月10天20小时开始起运 交运：命主于公历19...
四柱汉诺塔代码（c++）
12-14
四柱汉诺塔问题的源代码，自己用C++写的，盘子数目在整数范围内均可，都是盘子数目太多的话速度自然就。。。
用java写的根据公历日期获取阴历日期及生辰八字，及属相的demo
10-17
用java写的根据公历日期获取阴历日期及生辰八字，及属相的demo
四柱汉诺塔的c++实现
11-19
四柱汉诺塔的c++实现，关键在于最短路径的计算
java 拖动柱子上按钮_JAVA - 四柱汉诺塔最优移动次序展示
weixin_39999209的博客
02-16 114
/** 主函数** 包含了各个类之间的逻辑控制*/package Hanio;import java.awt.Color;import java.awt.Font;import java.util.*;import javax.swing.*;import Hanio.Pillars;import Hanio.Direction;import Hanio.Direction.Step;import...
递归（四）JAVA 汉诺塔（Hanoi Tower）问题的解决以及青蛙跳台阶问题的三种方式
char_m的博客
03-13 582
首先先看汉诺塔，汉诺塔问题是比较常见且经典的使用递归解决的问题。 那什么是汉诺塔呢？ 汉诺塔源自古印度的传说，源于印度一个古老传说。 大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。 大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，任何时候，在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。 通俗讲：总共有三根柱...
四柱汉诺塔及优化
ZWT_CSDN的博客
10-15 1166
问题描述 四柱汉诺塔，在A柱上有N个盘子，最少经过多少次移动能把盘子全部移动到D上？ 将盘子人为分成上下两个部分，上面部分是n-k个盘子，下面部分是k个盘子。那么想要把总计n个盘子从A柱挪到D柱就相当于： 通过CD柱把上面n-k个盘子挪到B柱 +通过C柱把下面k个盘子挪到D柱 +通过AC柱把B上面的n-k个盘子挪到D柱 我们假设四柱挪n-k盘子的步数需要f[n-k] 又，我们熟悉三柱汉诺塔挪动n个盘子需要步数2^n-1 因此，对于每一个k，我们有： long long temp=2*f[x-k]+pow
汉诺塔（Hanoi towers）- java
se-tester的专栏
06-13 239
汉诺塔递归算法如下： 输入的n表示的是环的数量 假如有三个柱子A，B，C，将A上的n个环移动到C上，始终保持由小到大的次序： 首先把前面n-1个环从A移动到B上，使用C作为辅助 然后将最后一个环从A移动到C上 最后将B上的n-1个环从B移动到C上，使用A作为辅助 public class Hanoi { public static void main(String[] args) { Scanner scanner = new Scanner(System.in)
uva 10254(四柱汉诺塔)
俯瞰风景
07-18 984
题意：给出四柱汉诺塔上初始柱子上圆盘的数量n，问最优多少次移动可以移动到另一个柱子上。 题解：可以参考四柱汉诺塔之初步探究和四柱汉诺塔实现这两篇论文，理解四柱汉诺塔的原理。 但是这道题n是从1到10000，递归太多层，而且需要用到大数，所以要找规律，f[i] = f[i - 1] + 2^k，k从1开始每k+1次计算f[i]后增大1，初始f[1] = 1。import java.math.Bi
汉诺塔问题（三柱及四柱）详解
1900的博客
08-19 6525
 汉诺塔（Hanoi Tower），又称河内塔，传说大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，任何时候，在小圆盘上都不能放大圆盘，且在三根柱子之间一次只能移动一个圆盘。问应该如何操作？ 需要求两个问题，一是求所需要的步数，二是求移动过程中每一步的做法步骤 汉诺塔问题...
扩展汉诺塔问题：四柱汉诺塔算法解析
资源摘要信息:"四柱汉诺塔，是在传统的汉诺塔问题基础上增加了一个附加条件，即有四根柱子而非传统的三根。这个问题是经典汉诺塔问题的一个扩展，旨在探讨更为复杂的情形下盘子移动的策略。汉诺塔问题本身是一个著名...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值