人工智能编程上机——三种搜索算法显示最短路径与花费时间

最新推荐文章于 2023-04-29 09:28:14 发布
最新推荐文章于 2023-04-29 09:28:14 发布
阅读量690 收藏 1
点赞数
文章标签： dfs bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44779710/article/details/117687738
版权
三种算法包括DFS、BFS、A*，程序具有可视化界面，拥有打开文件、保存文件的功能，鼠标左键、右键分别选择当前绘制线路的两个端点，鼠标中键选择搜索路径的起点和终点，附上代码。
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main{
	public static void main(String[] args) {
		MainWnd wd = new MainWnd();
	}
	
}


class MainWnd extends JFrame{
	private int X1[],Y1[],X2[],Y2[];//黑线坐标
	private int X1_b[],Y1_b[],X2_b[],Y2_b[];//蓝线坐标
	private int X1_r[],Y1_r[],X2_r[],Y2_r[];//红线坐标
	private int X_s = -1,Y_s = -1,X_e = -1 ,Y_e = -1;
	private int mapp[][];//邻接矩阵
	private int vst[];//遍历标记
	private int dx = 20, dy = 45;//坐标偏移
	private int st = 0,st_b = 0, st_r = 0;//栈顶
	private int start = -1,end = -1;
	JButton btn[]= {new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton(),
			new JButton(),new JButton(),new JButton(),new JButton(),new JButton()};
	JButton Dfs = new JButton("深度优先搜索");
	JButton Bfs = new JButton("宽度优先搜索");
	JButton A_ = new JButton("A*搜索");
	JButton Return = new JButton("重新描绘");
	JButton OPEN = new JButton("打开");
	JButton SAVE = new JButton("保存");
	JLabel Result = new JLabel();//显示答案
	JLabel signature = new JLabel("<html><body><p style='color :orange; font-size:15px; font-family = '宋体''>by：成亦峻<br/>AI Assignment</p></body></html>");
	
	private void Open() {
		FileDialog openDia = new FileDialog(new Frame(), "打开", FileDialog.LOAD);
		openDia.setVisible(true); 
		String address = openDia.getDirectory();
		String name = openDia.getFile();
		File f = new File(address,name);
		BufferedReader reader = null;
		try {
			InputStreamReader isr = new InputStreamReader(new FileInputStream(f) );
			reader = new BufferedReader(isr);
			String msg = "";
			int line_sum = -6;
			while((msg = reader.readLine()) != null) {
				if(line_sum == -6) {
					X_s = Integer.valueOf(msg).intValue();
				}
				else if(line_sum == -5) {
					Y_s = Integer.valueOf(msg).intValue();
				}
				else if(line_sum == -4) {
					X_e = Integer.valueOf(msg).intValue();
				}
				else if(line_sum == -3) {
					Y_e = Integer.valueOf(msg).intValue();
				}
				else if(line_sum == -2) {
					start = Integer.valueOf(msg).intValue();
				}
				else if(line_sum == -1) {
					end = Integer.valueOf(msg).intValue();
				}
				else {
					if(line_sum % 4 == 0) {
						X1[st] = Integer.valueOf(msg).intValue();
					}
					else if(line_sum % 4 == 1) {
						Y1[st] = Integer.valueOf(msg).intValue();
					}
					else if(line_sum % 4 == 2) {
						X2[st] = Integer.valueOf(msg).intValue();
					}
					else {
						Y2[st] = Integer.valueOf(msg).intValue();
						mapp[(X2[st]-dx)/60 + (Y2[st]-dy)/60 * 10][(X1[st]-dx)/60 + (Y1[st]-dy)/60 * 10] = 1;
						mapp[(X1[st]-dx)/60 + (Y1[st]-dy)/60 * 10][(X2[st]-dx)/60 + (Y2[st]-dy)/60 * 10] = 1;
						st ++;
					}
				}
				line_sum ++;
			}
			reader.close();
		}catch(IOException e) {
            e.printStackTrace();
        }
		
	}
	
	private void Save() {	
		FileDialog saveDia = new FileDialog(new Frame(), "保存", FileDialog.SAVE);
		saveDia.setVisible(true);
		String adress = saveDia.getDirectory();
		String name = saveDia.getFile();
		String msg = "";
		msg += X_s + "\r\n" + Y_s + "\r\n" + X_e + "\r\n" + Y_e + "\r\n" + start + "\r\n" +end + "\r\n";
		for(int i = 0;i < st; i ++) {
			msg += X1[i] + "\r\n" + Y1[i] + "\r\n" + X2[i] + "\r\n" + Y2[i] + "\r\n";
		}
		File f = new File(adress,name);
		try {
			FileWriter fw = new FileWriter(f);
			fw.write(msg);
			fw.close();
		}catch(IOException e){
			System.out.println(e.getMessage());
		}
	}
	
	//连线监听
	private MouseListener ML = new MouseListener() {
		public void mouseClicked(MouseEvent e) {
			String now = e.getSource().toString();
			String l = "",r = "";
			int nexti = 0;
			for(int i = 21;;i++) {
				if(now.charAt(i) == ',') {
					nexti = i+1;
					break;
				}
				l += now.charAt(i);
			}
			for(int i = nexti;;i++) {
				if(now.charAt(i) == ',') {
					break;
				}
				r += now.charAt(i);
			}
			int x = Integer.valueOf(l).intValue() + dx;
			int y = Integer.valueOf(r).intValue() + dy;
			int p = e.getButton();
			if(p == 1) {
				X1[st] = x;
				Y1[st] = y;
			}
			else if(p == 3){
				if(X1[st] == -1&& Y1[st] == -1) return;
				X2[st] = x;
				Y2[st] = y;
				mapp[(x-dx)/60 + (y-dy)/60 * 10][(X1[st]-dx)/60 + (Y1[st]-dy)/60 * 10] = 1;
				mapp[(X1[st]-dx)/60 + (Y1[st]-dy)/60 * 10][(x-dx)/60 + (y-dy)/60 * 10] = 1;
				st ++;
			}
			else {
				int Mark = (y-dy)/6 + (x-dx)/60;
				if(start == -1)	{
					start = Mark;
					X_s = x;
					Y_s = y;
				}
				else {
					end = Mark;
					X_e = x;
					Y_e = y;
				}
			}
			
			repaint();
			
			
			
		}
		public void mousePressed(MouseEvent e) {}
		public void mouseReleased(MouseEvent e) {}
		public void mouseEntered(MouseEvent e) {}
		public void mouseExited(MouseEvent e) {}
	};

	//返回监听
	private ActionListener RT = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			st = 0;
			st_b = 0;
			st_r = 0;
			start = -1;
			end = -1;
			X_s = X_e = Y_s = Y_e = -1;
			X1[0] = Y1[0] = -1;
			mapp = null; mapp = new int[100][100];
			Result.setFont(Result.getFont().deriveFont(20.0f));
			Result.setText("<html><body>请连接节点并选取起点与终点<br/>操作方法：<br/>鼠标左键与右键分别选择当前需要连接的两个节点<br/>鼠标中键选择起点和终点<br/>注：任两节点间距离为1，搜索速度为1</body></html>");
			repaint();
		}
	};
	
	//打开文件
	private ActionListener OP = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			st = 0;
			st_b = 0;
			st_r = 0;
			start = -1;
			end = -1;
			X_s = X_e = Y_s = Y_e = -1;
			X1[0] = Y1[0] = -1;
			mapp = null; mapp = new int[100][100];
			Result.setFont(Result.getFont().deriveFont(20.0f));
			Result.setText("<html><body>请连接节点并选取起点与终点<br/>操作方法：<br/>鼠标左键与右键分别选择当前需要连接的两个节点<br/>鼠标中键选择起点和终点<br/>注：任两节点间距离为1，搜索速度为1</body></html>");
			repaint();
			Open();
			repaint();
		}
	};
	
	//保存文件
	private ActionListener SA = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			Save();
		}
	};
	
	//dfs监听
	private ActionListener DFS = new ActionListener() {
		int min_step = 0x3f3f3f3f,all_time = 0;
		int go_Arr[];
		int st_Arr = 0;
		public void actionPerformed(ActionEvent e) {
			vst = null;
			vst = new int[100];
			st_b = 0;
			st_r = 0;
			go_Arr = null;
			go_Arr = new int[100];
			st_Arr = 0;
			all_time = -1;
			min_step = 0x3f3f3f3f;
			go_Arr[st_Arr] = start;
			st_Arr++;
			dfs(start,0);
			String res = "<html><body>dfs搜索结果如下：<br/>最短距离为："+min_step+"<br/>搜索所需时间为："+all_time+"<br/></body></html>"/*"最短距离为："+min_step+"<br/>搜索花费时间为："+all_time*/;
			Result.setFont(Result.getFont().deriveFont(24.0f));
			Result.setText(res);
			repaint();
		}
		void dfs(int x,int step) {
			all_time ++;
			if(x == end) {
				min_step = Math.min(step,min_step);
				mark_r();
			}
			if(step >= min_step)	return;
			vst[x] = 1;
			for(int i = 0;i < 100;i++) {
				if(i == x)	continue;
				if(mapp[x][i] == 1) {
					if(vst[i] == 0) {
						vst[i] = 1;
						X1_b[st_b] = (x%10) * 60 + dx;
						Y1_b[st_b] = (x/10) * 60 + dy;
						X2_b[st_b] = (i%10) * 60 + dx;
						Y2_b[st_b] = (i/10) * 60 + dy;
						st_b ++;
						go_Arr[st_Arr++] = i;
						dfs(i,step + 1);
						vst[i] = 0;
						if(st_Arr>0) st_Arr--;
					}
				}
			}
		}
		void mark_r() {
			st_r = 0;
			for(int i=0;i+1<st_Arr;i++) {
				X1_r[st_r] = (go_Arr[i]%10) * 60 + dx;
				Y1_r[st_r] = (go_Arr[i]/10) * 60 + dy;
				X2_r[st_r] = (go_Arr[i+1]%10) * 60 + dx;
				Y2_r[st_r] = (go_Arr[i+1]/10) * 60 + dy;
				st_r ++ ;
			}
		}
	};
	
	//bfs监听
	private ActionListener BFS = new ActionListener() {
		int all_time = 0;
		Queue<Integer> queue;
		boolean ok;
		int Father[],step[];
		public void actionPerformed(ActionEvent e) {
			all_time = 0;
			st_b = st_r = 0;
			vst = null;
			vst = new int[100];
			queue = new LinkedList<Integer>();
			ok = true;
			Father = new int[100];
			step = new int[100];
			queue.offer(start);
			vst[start] = 1;
			bfs();
			
			mark_r();
			String res = "<html><body>bfs搜索结果如下：<br/>最短距离为："+step[end]+"<br/>搜索所需时间为："+all_time+"<br/></body></html>"/*"最短距离为："+min_step+"<br/>搜索花费时间为："+all_time*/;
			Result.setFont(Result.getFont().deriveFont(24.0f));
			Result.setText(res);
			repaint();
		}
		void bfs() {
			while(!queue.isEmpty() && ok) {
				int x = queue.poll();
				for(int i=0;i<100;i++) {
					if(mapp[x][i] == 1) {
						if(vst[i] == 0) {
							vst[i] = 1;
							all_time ++;
							queue.offer(i);
							Father[i] = x;	step[i] = step[x] + 1;
							X1_b[st_b] = (x%10) * 60 + dx;
							Y1_b[st_b] = (x/10) * 60 + dy;
							X2_b[st_b] = (i%10) * 60 + dx;
							Y2_b[st_b] = (i/10) * 60 + dy;
							st_b ++;
							if(i == end) {
								ok = false;
								break;
							}
						}
					}
				}
			}
		}
		void mark_r() {
			int x1 = end, x2 = Father[end];
			while(x1 != start) {
				X1_r[st_r] = (x1 %10) * 60 + dx;
				Y1_r[st_r] = (x1 /10) * 60 + dy;
				X2_r[st_r] = (x2 %10) * 60 + dx;
				Y2_r[st_r] = (x2 /10) * 60 + dy;
				st_r ++ ;
				x1 = x2;
				x2 = Father[x1];
			}
		}
	};
	
	//A*监听
	private ActionListener A_x = new ActionListener(){
		int all_time = 0;
		Queue<Integer> queue;
		boolean ok;
		int Father[],G[],F[],H[];
		public void actionPerformed(ActionEvent e) {
			all_time = 0;
			st_b = st_r = 0;
			vst = null;
			vst = new int[100];
			queue = new LinkedList<Integer>();
			ok = true;
			Father = new int[100];
			G = new int[100];
			F = new int[100];
			H = new int[100];
			queue.offer(start);
			vst[start] = 1;
			A__();
			
			mark_r();
			String res = "<html><body>A*搜索结果如下：<br/>最短距离为："+G[end]+"<br/>搜索所需时间为："+all_time+"<br/>代价为："+F[end]+"</body></html>";
			Result.setFont(Result.getFont().deriveFont(24.0f));
			Result.setText(res);
			repaint();
		}
		void A__() {
			while(!queue.isEmpty() && ok) {
				int x = queue.poll();
				for(int i=0;i<100;i++) {
					if(mapp[x][i] == 1) {
						if(vst[i] == 0) {
							vst[i] = 1;
							all_time ++;
							queue.offer(i);
							Father[i] = x;	G[i] = G[x] + 1;
							H[i] = H[x] + 1;
							F[i] = H[i] + G[i];
							X1_b[st_b] = (x%10) * 60 + dx;
							Y1_b[st_b] = (x/10) * 60 + dy;
							X2_b[st_b] = (i%10) * 60 + dx;
							Y2_b[st_b] = (i/10) * 60 + dy;
							st_b ++;
							if(i == end) {
								ok = false;
								break;
							}
						}
					}
				}
			}
		}
		void mark_r() {
			int x1 = end, x2 = Father[end];
			while(x1 != start) {
				X1_r[st_r] = (x1 %10) * 60 + dx;
				Y1_r[st_r] = (x1 /10) * 60 + dy;
				X2_r[st_r] = (x2 %10) * 60 + dx;
				Y2_r[st_r] = (x2 /10) * 60 + dy;
				st_r ++ ;
				x1 = x2;
				x2 = Father[x1];
			}
		}
	};
	
	public MainWnd() {
		X1 = new int[100];X2 = new int[100];Y1 = new int[100];Y2 = new int[100];
		X1[0] = Y1[0] = -1;
		X1_b = new int[100];X2_b = new int[100];Y1_b = new int[100];Y2_b = new int[100];
		X1_r = new int[100];X2_r = new int[100];Y1_r = new int[100];Y2_r = new int[100];
		mapp = new int [100][100];
		vst = new int [100];
		setTitle("三种搜索及最短路查找");
		setSize(900,800);
		setVisible(true);
		setLocation(450,180);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		Container cp = getContentPane();
		cp.setLayout(null);
		int X = 0 , Y = 0;
		for(int i = 0; i < 100; i++) {
			cp.add(btn[i]);
			btn[i].setLocation(X,Y);
			btn[i].setSize(20,20);
			btn[i].addMouseListener(ML);
			Y = Y + 60;
			if((i+1)%10==0) {
				X = X + 60;
				Y = 0;
			}
		}
		
		cp.add(OPEN);OPEN.setLocation(700,30);OPEN.setSize(150,50);OPEN.addActionListener(OP);
		cp.add(SAVE);SAVE.setLocation(700,145);SAVE.setSize(150,50);SAVE.addActionListener(SA);
		cp.add(Dfs);Dfs.setLocation(700,260);Dfs.setSize(150,50);Dfs.addActionListener(DFS);
		cp.add(Bfs);Bfs.setLocation(700,375);Bfs.setSize(150,50);Bfs.addActionListener(BFS);
		cp.add(A_);A_.setLocation(700,490);A_.setSize(150,50);A_.addActionListener(A_x);
		cp.add(Return);Return.setLocation(700,605);Return.setSize(150,50);Return.addActionListener(RT);
		
		OPEN.setFont(OPEN.getFont().deriveFont(16.0f));
		SAVE.setFont(SAVE.getFont().deriveFont(16.0f));
		Dfs.setFont(Result.getFont().deriveFont(16.0f));
		Bfs.setFont(Bfs.getFont().deriveFont(16.0f));
		A_.setFont(A_.getFont().deriveFont(16.0f));
		Return.setFont(Return.getFont().deriveFont(16.0f));
		
		cp.add(Result);Result.setLocation(30,550);Result.setText("<html><body>请连接节点并选取起点与终点<br/>操作方法：<br/>鼠标左键与右键分别选择当前需要连接的两个节点<br/>鼠标中键选择起点和终点<br/>注：任两节点间距离为1，搜索速度为1</body></html>");
		Result.setSize(600,200);
		Result.setFont(Result.getFont().deriveFont(20.0f));
		
		cp.add(signature);
		//signature.setFont(Result.getFont().deriveFont(20.0f));
		signature.setSize(300,100);
		signature.setLocation(700,650);
		
		cp.validate();
	}
	
	public void paint(Graphics g2) {
		super.paint(g2);
		Graphics2D g = (Graphics2D)g2;
		g.setColor(Color.BLACK);
		g.setStroke(new BasicStroke(3.0f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND));
		
		for(int i = 0;i < st; i++) {
			g.drawLine(X1[i], Y1[i], X2[i], Y2[i]);
			g.fillOval(X1[i] - 9, Y1[i] - 5, 15, 15);
			g.fillOval(X2[i] - 9, Y2[i] - 5, 15, 15);
		}
			
		
		g.setColor(Color.BLUE);
		for(int i = 0;i < st_b; i++) {
			g.drawLine(X1_b[i], Y1_b[i], X2_b[i], Y2_b[i]);
			g.fillOval(X1_b[i] - 9, Y1_b[i] - 5, 15, 15);
			g.fillOval(X2_b[i] - 9, Y2_b[i] - 5, 15, 15);
		}
			
		
		g.setColor(Color.RED);
		for(int i = 0;i < st_r; i++) {
			g.drawLine(X1_r[i], Y1_r[i], X2_r[i], Y2_r[i]);
			g.fillOval(X1_r[i] - 9, Y1_r[i] - 5, 15, 15);
			g.fillOval(X2_r[i] - 9, Y2_r[i] - 5, 15, 15);
		}
			
		
		g.setFont(g.getFont().deriveFont(18.0f));
		if(X_s != 0 &&  Y_s !=-1) {
			g.drawString("start", X_s + 10, Y_s + 20);
			g.fillOval(X_s - 12, Y_s - 8, 22, 22);
			
		}
		if(X_e != 0 && Y_e != -1) {
			g.drawString("end", X_e + 10, Y_e + 20);
			g.fillOval(X_e - 12, Y_e - 8, 22, 22);
		}
	}
	
	
}

其中默认任意直接相连两点间距离为单位距离，则A* 算法估价函数H(n)恒唯一，则G(n)所占比例很大，A* 很接近于BFS，各位也可以将两点间距离改为实际距离然后重新A* 。

若有不足还望指正

buct_lurker
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
群智能算法 第4关：蚁群算法 - 商队旅行最短路径计算
admin的博客
10-04 1643
本关任务：使用 python 实现蚁群算法，并寻找商队旅行最短路径。
人工智能课程练习（5种最短路径+BP算法）
05-08
人工智能课的课后练习，使用JAVA编写，有演示界面。一个是使用了五种算法的最短路径求解；一个是神经网络的BP算法，大家有兴趣可以看看
旋转矩阵算法_实例 | Java实现旋转矩阵算法，一起深入学习算法，算法很重要哦！...
weixin_39542742的博客
11-22 405
↑ 点击上面 “时代Java”关注我们，关注新技术，学习新知识！矩阵旋转算法在计算机图形学中，是一种应用非常广泛的变换，是一种称为仿射变换的特殊变换，在仿射变换中的基本变换包括平移、旋转、缩放、剪切这几种。首先要明确旋转在二维中是绕着某一个点进行旋转，三维中是绕着某一个轴进行旋转。二维旋转中最简单的场景是绕着坐标原点进行的旋转，我们看下面矩阵数组的旋转：算法实现代码(可在线编辑运行实例，...
三种搜索算法
Ziy的博客
04-17 877
总结 老规矩–站在巨人的肩膀上前行，看大佬们的经验帖：算法入门–深度优先搜索 总结一下收获 深度优先搜索： 从一个顶点开始沿一条路走到底，直到到达终点或者不能走，回溯到上一节点，找到该层的其他节点，继续深搜。有递归和非递归实现。 缺点：难以寻找最优解，仅仅能寻找有解的情况。 优点：每次只用维护一个节点，内存消耗小。 广度优先搜索： 从一个顶点开始到下一层所有的节点都开一条路径，不回溯。一般用队列和while实现。 缺点：每一个节点入队，其同层的所有节点都要入队，在树的层次较深且子节点较多时内存消耗太大
求最短路径算法
最新发布
微信公众号：饺子泡牛奶
04-29 221
章节目录： 一、迪杰斯特拉算法 1.1 算法介绍 1.2 算法步骤 1.3 应用场景 二、弗洛伊德算法 2.1 算法介绍 2.2 算法步骤
数据结构课程设计报告--Dijkstra算法求最短路径.doc
05-30
数据结构课程设计报告--Dijkstra算法求最短路径 本文档是关于数据结构课程设计报告，主要介绍Dijkstra算法在求最短路径中的应用。下面是本文档的详细知识点总结： 目录结构 本文档的目录结构清晰，分为四个章节：...
数据结构与算法上机试验——栈实现十进制转换二进制（C语言）
11-23
适用于计算机类专业学生，试验报告
上机——信道容量的迭代算法.doc
05-07
上机——信道容量的迭代算法.doc
数值分析上机C语言代码.zip_三次样条插值_数值分析C语言编程上机实验
09-20
其次，龙贝格积分是数值积分的一种高效算法，尤其适用于高精度计算。它基于复化辛普森法则，通过对称性减少误差，通过逐步增加积分区间的细分来提高精度。龙贝格积分的C语言实现通常涉及到递归和误差控制。 牛顿...
计算机图形学上机指导——金刚石图案算法实现说明（MFC）.doc
05-07
计算机图形学上机指导——金刚石图案算法实现说明（MFC） 计算机图形学是计算机科学领域中的一个重要分支，它涉及到计算机生成和处理图形图像的技术和算法。金刚石图案是一种特殊的图形图像，它是将半径为r的圆周n...
人工智能课程设计最短路径搜索
01-05
人工智能课做的课程设计在地图中找最短路径搜索，排序算法不好地图大的话速度比较慢，参考下
人工智能之搜索算法
wangyong1034的博客
03-21 8342
通过搜索来解决问题 文章目录通过搜索来解决问题1. 什么是算法？2. 什么是搜索？3. 搜索算法3.1 如何做路径规划？3.2 搜索过...
蚁群算法在最短路中的matlab代码
zlunan的专栏
11-28 1133
下面的程序是蚁群算法在最短路中的应用，稍加扩展即可应用于机器人路径规划 function [ROUTES,PL,Tau]=ACASP(G,Tau,K,M,S,E,Alpha,Beta,Rho,Q) %% --------------------------------------------------------------- % ACASP.m % 蚁群算法动态寻路算法 ...
三大查找算法(原理+实现)
weixin_54950870的博客
09-12 1718
下面我介绍的是二分查找算法（递归实现）、插值查找算法（递归实现）、斐波那契查找算法（递归+非递归实现） 查找算法在我们不论是面试、工作中都十分重要，在海量数据中，如何提高查找效率，也是我们程序猿一直追求的目标。现在我就介绍其中最普遍的三种查找算法，希望对大家有所帮助。 首先，以上三种查找算法都基于同一个前提：就是有序 所以我们在进行查找之前，必须先对数组进行排序，而如何排序呢？我在之前的一篇文章有讲到对应的7大排序算法，用兴趣的朋友可以先去了解一下（链接附上），这里我就不再赘述了，直接进入正题...
【最短路径】 SPFA算法优化
weixin_30783913的博客
02-16 206
　　首先先明确一个问题，SPFA是什么？（不会看什么看，一边学去，传送门），SPFA是bellman-ford的队列优化版本，只有在国内才流行SPFA这个名字，大多数人就只知道SPFA就是一个顶尖的高效算法，却不知道还能继续优化，这个优化虽然也没有你想的那么麻烦，只不过多了几个判断语句罢了，5分钟就能学会，但是这也得运用到分类讨论，其实SPFA有三种优化方法，效果并不是很明显。 ...
人工智能基础——搜索算法
qq_21043585的博客
09-07 4371
文章目录引言第一课——搜索算法什么是搜索无信息搜索BFS（广度优先）一致代价搜索DFS（深度优先）深度受限搜索迭代加深DFS双向搜索有信息搜索（启发式）罗马尼亚度假问题贪婪搜索A*搜索存储受限的启发式搜索递归最佳优先搜索（RBFS）简化内存受限（SMA*）启发式函数 引言 本学期开设了人工智能基础这门课程，使用了《人工智能 一种现代方法》作为教材，整本书将尽一千多页。我觉得他内容其实很不错，但是阅读难度还是比较大的，对于问题的阐述有点过于复杂了，需要比较强大的阅读能力，并且难以圈划重点。 因此，我打算在每节
最短路径问题（最短路径）
不会思考的机器
06-27 777
最短路径问题 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 16506    Accepted Submission(s): 4940 Problem Description 给你n个点，m条无向边，每条边都有长度d和花
最短路径算法/最快路径算法--G-tree/TD-Gtree
nccccc12345的博客
04-08 2441
G-tree/TD-Gtree G-tree是由清华大学的李国良老师在2015年提出，发表论文在当年的TKDE中，并且在2019年将其扩展到时间依赖环境下，发表在当年的VLDB中。 G-tree的主要思路是将路网划分为若干个大小几乎相同子图，并且为子图创建一棵树。划分子图的大小是由两个参数来确定的：kl和kf，其中kl 用来控制叶子节点中，也就是最终划分完之后，每个子图中路网节点的个数。kf用来控制划分子图时，将一个大子图划分为几个小子图，例如kf=4，那么在划分下一级子图时，就是对每个当前子图切两刀，将每
最短路径算法 介绍
weixin_30481087的博客
05-10 103
http://www.5igis.com/ 据 Drew 所知最短路经算法现在重要的应用有计算机网络路由算法，机器人探路，交通路线导航，人工智能，游戏设计等等。美国火星探测器核心的寻路算法就是采用的D*（D Star）算法。 最短路经计算分静态最短路计算和动态最短路计算。 静态路径最短路径算法是外界环境不变，计算最短路径。主要有Dijkstra算法，A*（A Star）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值