模拟最短路径寻路（JAVA界面）

最新推荐文章于 2022-05-02 15:09:50 发布
最新推荐文章于 2022-05-02 15:09:50 发布
阅读量2.9k 收藏 11
点赞数 4
文章标签： java 算法 寻路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26924703/article/details/51424125
版权

大二的时候，数据结构老师留的第二个作业，总的来说收获很大，其中包含了bfs和Dijkstra。

首先是Map类：

package hjc;

public class Map {

	final static int[][] MyMap = 
		{
			{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1 },
			{ 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1 },
			{ 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1 },
			{ 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 }, 
			{ 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1 },
			{ 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 },
			{ 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 },
			{ 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1 },
			{ 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1 },
			{ 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1 },
			{ 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1 },
			{ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1 },
			{ 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1 },
			{ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
			{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
		};		
	
	static int[] start = {15, 15}; 
	static int[] aim={21, 24}; 

}

其中1和0分别代表了不可走和可走。

下面是MainView类：

package hjc;

import java.awt.BasicStroke;
import java.awt.Button;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.TextField;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

import javax.swing.JOptionPane;

public class MainView extends Frame implements ActionListener, KeyListener {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public static final int ScreenWidth = Toolkit.getDefaultToolkit()
			.getScreenSize().width;
	public static final int ScreenHeight = Toolkit.getDefaultToolkit()
			.getScreenSize().height;
	public static final int ExeWidth = 700;
	public static final int ExeHeight = 560;
	public static final int a = 15 ;

	private Image offScreenImage = null;
	private Image beijing = Toolkit.getDefaultToolkit().getImage(
			"image/beijing.jpg");
	private Image hua = Toolkit.getDefaultToolkit().getImage("image/hua.png");
	Button Rand = new Button("生成新地图");
	Button Randoa = new Button("自动随机起始点");
	Button FindForGdyx = new Button("广度优先寻路");
	Button FindForDijstra = new Button("迪杰斯特拉寻路");
	Button suodingo = new Button("锁定");
	Button suodinga = new Button("锁定");
	Button clear = new Button("清空障碍");
	TextField ta1 = new TextField("0");
	TextField ta2 = new TextField("0");
	TextField ta3 = new TextField("0");
	TextField ta4 = new TextField("0");

	int span = 20;
	boolean isFind1 = false;
	boolean isFind2 = false;
	boolean isFinding = false;
	int count1 = 0;
	int count2 = 0;
	int[] origin = Map.start;
	int[] aim = Map.aim;
	int[][] map = Map.MyMap;
	int[][] length = new int[Map.MyMap.length][Map.MyMap[0].length];
	int[][] visited = new int[Map.MyMap.length][Map.MyMap[0].length];
	Queue<int[][]> queue = new LinkedList<int[][]>();
	ArrayList<int[][]> searchProcess = new ArrayList<int[][]>();
	HashMap<String, int[][]> searchResult1 = new HashMap<String, int[][]>();
	HashMap<String, int[][]> searchResult2 = new HashMap<String, int[][]>();

	int[][] dir1 = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
	int[][] dir2 = { { 1, 1 }, { 1, -1 }, { -1, -1 }, { -1, 1 } };
	int[][] dir3 = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 }, { 1, 1 },
			{ 1, -1 }, { -1, -1 }, { -1, 1 } };

	public static void main(String[] args) {

		new MainView();

	}

	public void init() {

		count1 = 0;
		count2 = 0;
		isFind1 = false;
		isFind2 = false;
		origin = Map.start;
		aim = Map.aim;
		queue = new LinkedList<int[][]>();
		searchProcess = new ArrayList<int[][]>();
		searchResult1 = new HashMap<String, int[][]>();
		searchResult2 = new HashMap<String, int[][]>();
		visited = new int[Map.MyMap.length][Map.MyMap[0].length];
		length = new int[Map.MyMap.length][Map.MyMap[0].length];

		repaint();

	}

	public MainView() {

		this.setTitle("最短路径");
		this.setLayout(null);
		Image icon = Toolkit.getDefaultToolkit().getImage("image/icon.png");
		this.setIconImage(icon);
		this.setBounds((ScreenWidth - ExeWidth) / 2,
				(ScreenHeight - ExeHeight) / 2, ExeWidth, ExeHeight);

		Rand.setBounds(550, 100, 100, 30);
		Randoa.setBounds(550, 350, 100, 30);
		FindForDijstra.setBounds(550, 425, 100, 30);
		FindForGdyx.setBounds(550, 500, 100, 30);
		suodingo.setBounds(620, 180, 50, 20);
		suodinga.setBounds(620, 250, 50, 20);
		clear.setBounds(550, 300, 70, 20);
		ta1.setBounds(540, 150, 50, 20);
		ta2.setBounds(620, 150, 50, 20);
		ta3.setBounds(540, 220, 50, 20);
		ta4.setBounds(620, 220, 50, 20);

		Rand.setBackground(Color.CYAN);
		Randoa.setBackground(Color.CYAN);
		FindForDijstra.setBackground(Color.ORANGE);
		FindForGdyx.setBackground(Color.ORANGE);
		suodingo.setBackground(Color.PINK);
		suodinga.setBackground(Color.PINK);
		clear.setBackground(Color.GRAY);

		Rand.addActionListener(this);
		Randoa.addActionListener(this);
		FindForDijstra.addActionListener(this);
		FindForGdyx.addActionListener(this);
		suodingo.addActionListener(this);
		suodinga.addActionListener(this);
		clear.addActionListener(this);
		ta1.addKeyListener(this);
		ta2.addKeyListener(this);
		ta3.addKeyListener(this);
		ta4.addKeyListener(this);

		this.add(ta1);
		this.add(ta2);
		this.add(ta3);
		this.add(ta4);
		this.add(FindForDijstra);
		this.add(FindForGdyx);
		this.add(Rand);
		this.add(Randoa);
		this.add(suodingo);
		this.add(suodinga);
		this.add(clear);

		this.addMouseListener(new MouseAdapter() {
			public void mousePressed(MouseEvent e) {
				int x = e.getX();
				int y = e.getY() - 30;
				System.out.println(x + "----" + y);
			}
		});

		this.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent arg0) {
				System.exit(0);
			}
		});

		this.setResizable(false);
		this.setVisible(true);

	}

	public void update(Graphics g) {

		if (offScreenImage == null) {
			offScreenImage = this.createImage(ExeWidth, ExeHeight);
		} else {
			offScreenImage = null;
			offScreenImage = this.createImage(ExeWidth, ExeHeight);
		}
		Graphics goff = offScreenImage.getGraphics();
		paint(goff);
		goff.dispose();
		g.drawImage(offScreenImage, 0, 0, null);

	}

	public void paint(Graphics g) {

		Color c = g.getColor();

		Graphics2D g2d = (Graphics2D) g;
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
				RenderingHints.VALUE_ANTIALIAS_ON);
		g2d.setColor(Color.BLACK);

		map[origin[0]][origin[1]] = 3;
		map[aim[0]][aim[1]] = 4;
		count1 = 0;
		count2 = 0;

		//g2d.drawImage(beijing, 0, 0, this);
		//g2d.drawImage(hua, 250, 200, this);

		for (int i = 0; i < 32; i++) {
			for (int j = 0; j < 32; j++) {
				if (Map.MyMap[i][j] == 0) {
					g2d.setColor(Color.BLACK);
					g2d.drawRect(20 + j * a, 50 + i * a, a, a);
				} else if (Map.MyMap[i][j] == 1) {
					g2d.setColor(Color.GRAY);
					g2d.fillRect(20 + j * a, 50 + i * a, a, a);
				} else if (Map.MyMap[i][j] == 2) {
					g2d.setColor(Color.RED);
					g2d.fillRect(20 + j * a, 50 + i * a, a, a);
				} else if (Map.MyMap[i][j] == 3) {
					g2d.setColor(Color.RED);
					g2d.fillRect(20 + j * a, 50 + i * a, a, a);
				} else if (Map.MyMap[i][j] == 4) {
					g2d.setColor(Color.BLUE);
					g2d.fillRect(20 + j * a, 50 + i * a, a, a);
				}
			}
		}

		for (int k = 0; k < searchProcess.size(); k++) {
			int[][] edge = searchProcess.get(k);
			int[] point1 = getPosition(edge[0][1], edge[0][0]);
			int[] point2 = getPosition(edge[1][1], edge[1][0]);
			g2d.setColor(Color.BLACK);
			//float lineWidth = 1.5f;
			//g2d.setStroke(new BasicStroke(lineWidth));
			g2d.drawLine(point1[0], point1[1], point2[0], point2[1]);
		}

		int[] temp1 = aim;
		while (isFind1) {
			try {
				count1++;
				int[][] tempA = searchResult1.get(temp1[0] + ":" + temp1[1]);
				int[] point1 = getPosition(tempA[0][1], tempA[0][0]);
				int[] point2 = getPosition(tempA[1][1], tempA[1][0]);
				g2d.setColor(Color.RED);
				float lineWidth = 3.0f;
				g2d.setStroke(new BasicStroke(lineWidth));
				g2d.drawLine(point2[0], point2[1], point1[0], point1[1]);
				if (tempA[1][0] == origin[0] && tempA[1][1] == origin[1]) {
					break;
				}
				temp1 = tempA[1];
			} catch (Exception e) {
				break;
			}

		}

		int[] temp2 = aim;
		while (isFind2) {
			try {
				int[][] tempA = searchResult2.get(temp2[0] + ":" + temp2[1]);
				
				if (tempA[1][0] == origin[0] && tempA[1][1] == origin[1]) {
					break;
				}
				int[] point1 = getPosition(tempA[0][1], tempA[0][0]);
				int[] point2 = getPosition(tempA[1][1], tempA[1][0]);
				g2d.setColor(Color.RED);
				float lineWidth = 3.0f;
				g2d.setStroke(new BasicStroke(lineWidth));
				g2d.drawLine(point2[0], point2[1], point1[0], point1[1]);
				count2++;
				temp2 = tempA[0];
			} catch (Exception e) {
				break;
			}

		}

		g2d.setColor(Color.BLACK);
		g2d.drawString("搜索次数：" + searchProcess.size(), 570, 50);
		if (isFind1) {
			g2d.drawString("最短长度：" + count1, 570, 80);
		}
		if (isFind2) {
			g2d.drawString("最短长度：" + count2, 570, 80);
		}

		g.setColor(c);

	}

	public void dijstra() {

		new Thread() {

			public void run() {

				isFinding = true;

				for (int i = 0; i < length.length; i++) {
					for (int j = 0; j < length[0].length; j++) {
						length[i][j] = 10000;
					}
				}

				boolean flag = true;
				int[] start = { origin[0], origin[1] };
				visited[origin[1]][origin[0]] = 1;

				for (int[] a : dir1) {

					int row = start[0] + a[0];
					int col = start[1] + a[1];

					if (row < 0 || row >= map.length || col < 0
							|| col >= map[0].length)
						continue;
					if (map[row][col] == 1)
						continue;

					length[row][col] = 2;

					String key = row + ":" + col;
					int[][] al = new int[][] { { start[0], start[1] },
							{ row, col } };
					searchResult2.put(key, al);

					searchProcess.add(new int[][] { { start[0], start[1] },
							{ row, col } });

				}

				for (int[] b : dir2) {

					int row = start[0] + b[0];
					int col = start[1] + b[1];

					if (row < 0 || row >= map.length || col < 0
							|| col >= map[0].length)
						continue;
					if (map[row][col] == 1 || map[row][col - b[1]] == 1
							|| map[row - b[0]][col] == 1)
						continue;

					length[row][col] = 3;

					String key = row + ":" + col;
					int[][] al = new int[][] { { start[0], start[1] },
							{ row, col } };
					searchResult2.put(key, al);

					searchProcess.add(new int[][] { { start[0], start[1] },
							{ row, col } });

				}

				repaint();

				loop: while (flag) {

					try {
						int[] temp = new int[2];
						boolean is = false;
						int minLen = 10000;
						for (int i = 0; i < visited.length; i++) {
							for (int j = 0; j < visited[0].length; j++) {
								if (visited[i][j] == 0) {
									if (minLen > length[i][j]) {
										minLen = length[i][j];
										temp[0] = i;
										temp[1] = j;
										is = true;
									}
								}
							}
						}

						if (map[temp[0]][temp[1]] == 1 || is == false) {
							JOptionPane.showMessageDialog(null, "对不起，找不到路径！",
									"错误", JOptionPane.ERROR_MESSAGE);
							break loop;
						}

						visited[temp[0]][temp[1]] = 1;

						repaint();

						int length1 = length[temp[0]][temp[1]];

						int index = 0;
						for (int[] a1 : dir3) {

							index++;
							int row = temp[0] + a1[0];
							int col = temp[1] + a1[1];

							if (row < 0 || row >= map.length || col < 0
									|| col >= map[0].length)
								continue;
							if (index <= 4 && map[row][col] == 1)
								continue;
							if (index > 4 && map[row][col] == 1
									|| map[row][col - a1[1]] == 1
									|| map[row - a1[0]][col] == 1)
								continue;

							int length2 = length[row][col];
							int lengthSum = 0;
							if (index <= 4) {
								lengthSum = length1 + 2;
							} else if (index > 4) {
								lengthSum = length1 + 3;
							}

							if (length2 > lengthSum) {

								String key = row + ":" + col;
								searchResult2.put(key, new int[][] {
										{ temp[0], temp[1] }, { row, col } });

								length[row][col] = lengthSum;

								if (length2 == 10000) {
 
								
									searchProcess
											.add(new int[][] {
													{ temp[0], temp[1] },
													{ row, col } });

								}

							}

							if (row == aim[0] && col == aim[1]) {

								repaint();
								break loop;

							}
						}

						Thread.sleep(span);

					} catch (Exception e) {
						JOptionPane.showMessageDialog(null, "对不起，找不到路径！", "错误",
								JOptionPane.ERROR_MESSAGE);
						break loop;
					}
				}

				isFind2 = true;
				isFinding = false;

			}

		}.start();

	}

	public void gdyx() {

		new Thread() {

			public void run() {

				isFinding = true;
				boolean flag = true;
				int[][] start = { { origin[0], origin[1] },
						{ origin[0], origin[1] } };
				queue.offer(start);

				loop: while (flag) {

					try {
						int[][] currentEdge = queue.poll();
						int[] tempTarget = currentEdge[1];

						if (visited[tempTarget[1]][tempTarget[0]] == 1) {
							continue;
						}

						visited[tempTarget[1]][tempTarget[0]] = 1;

						searchProcess.add(currentEdge);

						searchResult1.put(tempTarget[0] + ":" + tempTarget[1],
								new int[][] { currentEdge[1], currentEdge[0] });

						repaint();
						Thread.sleep(span);

						if (tempTarget[0] == aim[0] && tempTarget[1] == aim[1]) {
							break;
						}

						int currCol = tempTarget[1];
						int currRow = tempTarget[0];

						for (int[] a : dir1) {

							int i = a[0];
							int j = a[1];

							if (i == 0 && j == 0) {
								continue;
							}

							if (currRow + i >= 0 && currRow + i < map.length
									&& currCol + j >= 0
									&& currCol + j < map[0].length
									&& map[currRow + i][currCol + j] != 1) {

								int[][] tempEdge = {
										{ tempTarget[0], tempTarget[1] },
										{ currRow + i, currCol + j } };

								queue.offer(tempEdge);

							}
						}

						for (int[] b : dir2) {

							int i = b[0];
							int j = b[1];

							if (i == 0 && j == 0) {
								continue;
							}
							if (currRow + i >= 0 && currRow + i < map.length
									&& currCol + j >= 0
									&& currCol + j < map[0].length
									&& map[currRow + i][currCol + j] != 1
									&& map[currRow][currCol + j] != 1
									&& map[currRow + i][currCol] != 1) {

								int[][] tempEdge = {
										{ tempTarget[0], tempTarget[1] },
										{ currRow + i, currCol + j } };

								queue.offer(tempEdge);

							}
						}

					} catch (Exception e) {

						JOptionPane.showMessageDialog(null, "对不起，找不到路径！", "错误",
								JOptionPane.ERROR_MESSAGE);
						break loop;

					}

				}

				isFind1 = true;
				isFinding = false;
				repaint();

			}

		}.start();

	}

	public int[] getPosition(int row, int col) {

		int xOffset = (row + 1) * 15 + 20 - 7;
		int yOffset = (col + 1) * 15 + 50 - 7;

		return new int[] { xOffset, yOffset };

	}

	public int getRand() {

		Random rand = new Random();
		int i = rand.nextInt(32);
		return i;
	}

	public void changeOA(int[] oa) {

		int x = getRand();
		int y = getRand();
		if (map[x][y] != 1 && map[x][y] != 3 && map[x][y] != 4) {
			oa[0] = x;
			oa[1] = y;
		}
		loop: while (map[x][y] == 1 || map[x][y] == 3 || map[x][y] == 4) {
			x = getRand();
			y = getRand();
			if (map[x][y] != 1 && map[x][y] != 3 && map[x][y] != 4) {
				oa[0] = x;
				oa[1] = y;
				break loop;
			}
		}

	}

	public void createMap() {

		for (int i = 0; i < 380; i++) {
			int y = getRand();
			int x = getRand();
			while (map[y][x] == 1) {
				y = getRand();
				x = getRand();
			}
			map[y][x] = 1;
		}

	}

	public void suodingo() {

		for (int i = 0; i < 32; i++) {
			for (int j = 0; j < 32; j++) {
				if (map[i][j] == 3) {
					map[i][j] = 0;
				}
			}
		}
		int x = Integer.parseInt("0" + ta1.getText());
		int y = Integer.parseInt("0" + ta2.getText());
		if (x >= 0 && x <= 31 && map[x][y] == 0) {
			origin[0] = x;
			origin[1] = y;
		} else {
			JOptionPane.showMessageDialog(null, "对不起，输入有误！", "错误",
					JOptionPane.ERROR_MESSAGE);
		}

	}

	public void suodinga() {

		for (int i = 0; i < 32; i++) {
			for (int j = 0; j < 32; j++) {
				if (map[i][j] == 4) {
					map[i][j] = 0;
				}
			}
		}
		int x = Integer.parseInt("0" + ta3.getText());
		int y = Integer.parseInt("0" + ta4.getText());
		if (x >= 0 && x <= 31 && map[x][y] == 0) {
			aim[0] = x;
			aim[1] = y;
		} else {
			JOptionPane.showMessageDialog(null, "对不起，输入有误！", "错误",
					JOptionPane.ERROR_MESSAGE);
		}

	}

	public void setText() {

		ta1.setText(origin[0] + "");
		ta2.setText(origin[1] + "");
		ta3.setText(aim[0] + "");
		ta4.setText(aim[1] + "");

	}

	public void clear() {

		init();
		for (int i = 0; i < 32; i++) {
			for (int j = 0; j < 32; j++) {
				if (map[i][j] == 1) {
					map[i][j] = 0;
				}
			}
		}

	}

	public void actionPerformed(ActionEvent e) {

		if (e.getSource() == FindForGdyx && isFinding == false) {

			init();
			setText();
			gdyx();

		} else if (e.getSource() == FindForDijstra && isFinding == false) {
			init();
			setText();
			dijstra();
		} else if (e.getSource() == Rand && isFinding == false) {

			for (int i = 0; i < 32; i++) {
				for (int j = 0; j < 32; j++) {
					map[i][j] = 0;
				}
			}
			init();
			createMap();

			repaint();

		} else if (e.getSource() == Randoa && isFinding == false) {

			for (int i = 0; i < 32; i++) {
				for (int j = 0; j < 32; j++) {
					if (map[i][j] == 3 || map[i][j] == 4) {
						map[i][j] = 0;
					}
				}
			}
			init();
			changeOA(origin);
			changeOA(aim);
			setText();

			repaint();

		} else if (e.getSource() == suodingo && isFinding == false) {

			init();
			suodingo();
			repaint();

		} else if (e.getSource() == suodinga && isFinding == false) {

			init();
			suodinga();
			repaint();

		} else if (e.getSource() == clear && isFinding == false) {

			clear();
			repaint();

		}

	}

	public void keyPressed(KeyEvent e) {

		int keyChar = e.getKeyChar();
		if (keyChar >= KeyEvent.VK_0 && keyChar <= KeyEvent.VK_9) {

		} else {
			e.consume();
		}

	}

	public void keyReleased(KeyEvent e) {

	}

	public void keyTyped(KeyEvent e) {

	}

}
源码下载地址：http://pan.baidu.com/s/1jIcvoGI

心本逍遥灬
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构实验---最短路径C实现附带及简单界面
zx1772874955的博客
12-21 669
数据结构实验—最短路径C实现附带及简单界面 前言： 最短路径算法是图论中比较重要的算法之一，我们在课本中学到的最短路径算法有两种，分别为Dijkstra 算法 和 Floyd 算法，本文中采用的是 Dijkstra算法，该部分核心代码由我的同学完成，在征得其同意的情况下我们决定将代码分享给大家，虽然可能很蹩脚其中有很多不足之处，但是希望可以给需要的同学帮助。 等过一阵子，我会更新整理Floyd版本的算法。 下面展示C语言的代码。 #include"stdio.h" #include"malloc.h" #i
java 具有图形界面的最短路径问题的求解
06-17
java 具有图形界面的最短路径问题的求解
最短路径查询系统图形界面
11-19
输入起始城市，目的城市，然后得出它们之间的最短路径 图形界面实现
最短路径程序演示-vc代码有界面
12-14
最短路径程序演示-vc代码有界面最短路径程序演示-vc代码有界面
数据结构课设：最短路径图形界面(C++)
m0_51409962的博客
05-02 3638
文章目录前言一、QT是什么？二、课程设计1.结点设计2.构造函数3.获取顶点和边的信息4.Floyd算法5.路径输出三、图形界面UI(一些细节，篇幅有限)1.固定窗口2.画箭头四、打包最终效果展示 前言 `博主是一名大二的学生，数据结构课题是城市最少交通时间，由于需要图形界面，所以自学了一点QT(B站的视频)，基于C++所学知识和Floyd算法完成了课程设计。本文是我的课设报告分享，之后如果有需要会分享打包好的程序和源码供大家参考。 一、QT是什么？ QT是一个跨平台的 C++ 开发库，是一个跨平台的C
毕业设计 最短路径算法.zip
最新发布
02-23
- **实验结果**：展示算法的实际应用，可能包括模拟图的最短路径、路径长度等。 - **优化与改进**：可能对现有算法进行优化，如使用数据结构提高效率，或者针对特定问题提出新的解决方案。 - **报告撰写**：详细记录...
java基于蚁群算法路由选择可视化动态模拟(源代码)
10-21
蚁群算法（Ant Colony Optimization, ACO）是一种启发式优化方法，它受到自然界中蚂蚁寻找食物路径行为的启发，能够有效地解决复杂的优化问题，如最短路径问题。在计算机网络中，路由选择是数据传输的关键环节，而蚁...
java小游戏（迷宫）.zip
12-16
Dijkstra算法是一种用于寻找图中两点间最短路径的算法，而A*算法在Dijkstra的基础上引入了启发式函数，提高了寻路效率。在这个游戏中，可能会通过模拟角色移动并更新节点状态来实现这些算法。 3. **图形用户界面...
Java游戏使命的召唤源码
06-07
寻路算法（如A*算法）可以帮助游戏中的角色找到最短路径。碰撞检测算法可以判断游戏对象之间的碰撞。游戏逻辑算法则涉及游戏规则的执行，比如角色的移动规则、攻击判定等。 面向对象编程（OOP）是Java的强项，它...
A*自动寻路算法实现（java）
03-08
下载本程序仅可演示A*自动寻路算法实现（java），该程序是基于我写的网络版贪吃蛇基础上编写的（网络版贪吃蛇下载地址：https://download.csdn.net/download/w110713121/15657669）。wasd键控制太阳的方向，鼠标左击目的地，会根据A*自动寻路算法计算出一条最优路线，太阳按最优路线移动。
基于JAVA的迷宫自动寻路算法实现
12-20
通过鼠标点击来获取一个目的地，然后方块自动寻路并到达目的地，提供了Keylistener借口和Runnable接口，可进行相关扩展。
java 环境下的最短路径动画演示，非常实用
04-22
这是确定起点的最短路径动画演示 - 即已知起始结点，求最短路径的问题的动画演示.This is a animation of according a knowing starting point to determine the shortest path's animation - that is, the starting node is known,and find the shortest path .
迷宫寻路实现java版
12-13
利用java语言实现简单的自动寻路算法，再生成的随机地图中循环搜索，若找到可用路径则给出路径示意图，否则不显示路径。本资源解压后是一个java源文件，可以导入到编译器（如 myEclimpse）后运行（Test是主类,运行它则可）. 此算法给出的路径不是最短路径，只是各种可用路径中的一种。 欢迎各位高手指教。。。。
java ai寻路_AI自动寻路
weixin_32558567的博客
02-13 251
1.首先把游戏场景中的物体设为静态2.选中Window中的Navigation，点击Bake进行场景烘焙3.在需要寻路的游戏对象上添加NavMeshAgent组件。调整其AgentSize大小与游戏对象适应。4.新建脚本，挂在需要寻路的对象身上。using UnityEngine;using System.Collections;public class Enemy_Move : MonoBeha...
A*自动寻路算法—java版
newbie的博客
06-16 8110
前段时间一直在写一个小游戏，需要用到自动寻路，于是就百度了一番，终于完成了，现在将原理及代码展示出来，方便有兴趣的朋友参考。说明一下，本次只展示了上下左右四个方向的移动。如图：如果从A点走到B点，有很多条路线，如何自动找到路线，以及如何找到最短的路线，就是这次要解决的问题。首先，需要讲解一下计算的公式，F=G+H，主要用于判断最佳路线。G：（左上角数值）起点到当前点的消耗（即步数），比如C点，与A...
棋盘的最短路径问题java_【leetcode】64. Minimum Path Sum 棋盘最短路径
weixin_42367221的博客
03-05 480
1. 题目Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.Note: You can only move either down or right a...
Java 游戏自动寻路,自动寻路等于垃圾游戏！跑图才是真浪漫？大人，这次时代真的变了...
weixin_35863455的博客
03-14 309
不管是RPG游戏还是沙盒游戏，玩家在游戏内的跑动，和NPC的对话，其实都是和整个游戏之间的互动，为了一个任务东奔西跑也是一种乐趣。自动寻路的存在就是为了让这个过程变得简便，可是有的玩家偏偏不买账，认为这个功能让游戏变成了垃圾。不少玩家排斥自动寻路的原因之一可能就是这个功能破坏了这种玩家的主动性，剥夺了玩家的一部分快乐。他们认为这个功能让玩游戏中的“玩”这个字变得可有可无了，都不用操作，那干脆就把游...
用c语言写迷宫寻路，记录最短路径
05-11
好的，我可以为您提供一个简单的迷宫寻路算法的C语言实现，但是最短路径需要使用更复杂的算法，比如Dijkstra算法或A*算法。以下是一个基于BFS算法的迷宫寻路程序，可记录最短路径： ```c #include #include #...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值