DFS（深度优先搜索）

求有向图中的最短路径（JAVA+DFS算法实现）

问题描述

给定一个有向图，如下图所示，求从1号顶点到5号顶点的最短路径。

输入数据格式为第一行输入顶点数和边数，从第二行开始每一行输入3个整数，分别代表连接顶点的边和权重。

例如：1 2 2，表示从1号顶点到2号顶点连接的边，权重为2。

Input：
5 8
1 2 2
1 5 10
2 3 3
2 5 7
3 1 4
3 4 4
4 5 5
5 3 3
Output：
9

算法实现

package test2;

import java.util.Scanner;

public class dfstest {

	static int[][] edges=new int[100][100];
	static int[] vertes=new int[100];
	static int n,m,min=Integer.MAX_VALUE;
	static Scanner scanner=new Scanner(System.in);
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		n=scanner.nextInt();
		m=scanner.nextInt();
		for (int i = 1; i <= n; i++) {//n个顶点
			for (int j = 1; j <=m; j++) {//m条边
				if (i==j) {
					edges[i][j]=0;
				}else {
					edges[i][j]=Integer.MAX_VALUE;
				}
			}
		}
		 
			for (int j = 1; j <=m; j++){//因为有m条边
				int a=scanner.nextInt();
				int b=scanner.nextInt();
				int c=scanner.nextInt();
				edges[a][b]=c;
 		}
		vertes[1]=1;
		dfs(1,0);
		System.out.println(min);
		
	}
	public static void dfs(int cur,int dis) {//cur为当前顶点，dis为经过路径长度
		if (dis>min) {
			return;
		}
		/**
         * 判断是否达到最后一个结点，更新最小值，返回
         * */
		if (cur==n) {
			if (dis<min) {
				min=dis;
				return;
			}
		}
		/**
         * 当前点到其他各点之间可连通但是还未添加进来时，遍历执行
         * */
		for (int i = 1; i <=n; i++) {
			if (edges[cur][i]!=Integer.MAX_VALUE&&vertes[i]==0) {
				vertes[i]=1;
				dfs(i,dis+edges[cur][i]);
				//回溯
				vertes[i]=0;
			}
		}
		return;
		
	}
}

————————————————
版权声明：本文为CSDN博主「梅森上校」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/seagal890/article/details/96048023

DFS求迷宫最小路径（dfs用递归一步步试探，在所有路径中选出最短的一条路径）

可能是求最长路径，题目忘了，原理应该一致

package test2;

import java.util.Scanner;

public class dfsmg {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 Scanner in = new Scanner(System.in);
		 while (in.hasNext()) {
			String[] strn=in.nextLine().split(",");
			int M=Integer.valueOf(strn[0]);
			int N=Integer.valueOf(strn[1]);
			int[][] a=new int[M][N];
			for (int i = 0; i < a.length; i++) {
				String[] str=in.nextLine().split(",");
				for (int j = 0; j < a[0].length; j++) {
					a[i][j]=Integer.valueOf(str[j]);
				}
			}//输入矩阵
			int max=0;
			int[][] b=new int[][]{{-1,0},{0,1},{1,0},{0,-1}};//负责上下左右
			for (int i = 0; i < a.length; i++) {
				for (int j = 0; j < a[0].length; j++) {
					if (a[i][j]==1) {
						int res=dfs(i,j,M,N,a,b);
						max=Math.max(max, res);
					}
				}
			}
			System.out.print(max);
		}
	}

	 
	private static int dfs(int i, int j, int m, int n, int[][] edges,
			int[][] sxzy) {
		// TODO Auto-generated method stub

		int num=1;
		edges[i][j]=0;//
		int k=0;
		while( k < 4) {
			int i2=i+sxzy[k][0];//-1，0，1，0，上下移
			int j2=j+sxzy[k][1];//0，1，0，-1，左右移
			if (pd(i2,j2,m,n)&&edges[i2][j2]==1) {
				num=num+dfs(i2, j2, m, n, edges, sxzy);
			}
			k++;
		}
		return num;
	}


	private static boolean pd(int i2, int j2, int m, int n) {
		// TODO Auto-generated method stub
		return j2>=0&&i2>=0&&i2<m&&j2<n;
	}

	

}

需要输入起点终点

package test2;
 
import java.util.Scanner;

public class maybeDfsx1y1{

	static 	int c=Integer.MAX_VALUE;//步数
	static int x1,y1,x2,y2;//起点坐标终点坐标
	static int[][] sxzy={{-1,0},{1,0},{0,-1},{0,1}};//上下左右移动
	static int[][] mg={{0,0,1,1,1},
		{0,0,1,1,1},
        {0,1,0,1,1},
        {1,0,1,1,1},
        {0,0,0,0,0}
		 };//迷宫
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner=new Scanner(System.in);
		x1=scanner.nextInt();
		y1=scanner.nextInt();
		x2=scanner.nextInt();
		y2=scanner.nextInt();
		dfs(x1,y1,0);
		System.out.println(c);
	}
	static void dfs(int x,int y,int dis){
		int xx=0,yy=0;
		if (x==x2&&y==y2) {
			c=Math.min(c, dis);
			return;
		}
		mg[x][y]=1;
		for (int k = 0; k < 4; k++) {
			xx=x+sxzy[k][0];
			yy=x+sxzy[k][1];
			if (xx<0||yy<0||xx>=5||yy>=5||mg[xx][yy]==1) {
				continue;
			}
			dfs(xx, yy, dis+1);
			mg[xx][yy]=0;
		}
	}
}