算法训练,逗志芃的暴走(Java代码)-蓝桥杯/leetcode

蓝桥杯试题 算法训练 逗志芃的暴走(Java代码)

资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述
　　逗志芃是有妹子的现充，但是有时候妹子就是烦恼。因为逗志芃太逗了，所以这段时间妹子对逗志芃发动了技能无理取闹，妹子要去玩很多的景点。由于逗志芃之前抽机花费了太多的时间，不久以后又要微积分考试了，所以现在被妹子搞成暴走状态了。但是妹子永远是上帝，所以逗志芃只能带妹子出去玩，不过为了节约时间，他希望找到一条花费时间最少的一次性游览线路。
输入格式
　　第一行1个数n，表示逗志芃所在的城市有多少个景点，接下来是一个n*n的矩阵。a(i，j)表示i号景点到j号景点的路上花费的时间是多少。
　　接下来是一个数m，表示逗志芃妹子要去去的景点数目。由于妹子在无理取闹，所以可能会有重复的景点，不过只要去一次就可以了。接下来是m个数，就是妹子要去的景点编号。
输出格式 　一个数，最少的花费时间。
样例输入
3
0 1 2
1 0 3
2 3 0
3
2 3 1

样例输出 3

数据规模和约定 　　0<n<=30，0<m<=20，时间<=1000000

这个题基本就是一个搜索可以解决的问题,但是他给的答案要进行一次弗罗伊德最短路径寻找,一开始
的路径矩阵,并不是每一个点到达其他点的最短路径,需用查找各个点是不是还有间接路径更短的方法,我就是通过一个二维数组存取各个点的距离,然后通过弗罗伊重排,然后通过dfs,进行全排列,找到最小路径

package com.chbcraft.dps;
import java.util.ArrayList;
import java.util.Scanner;

/**
 *  暴走的逗志芃
 * @author Headphone_Sang
 *
 */
public class ViolentWalk {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();//全部的景点的数目
		int[][] distances = new int[n+1][n+1];//每个景点到其他景点的距离
		scanner.nextLine();
		for(int i =1;i<=n;i++) {
			for(int j = 1;j<=n;j++) {
				distances[i][j] = scanner.nextInt();
			}
			scanner.nextLine();
		}
		Util.setDistances(distances);
		int m = scanner.nextInt();//女朋友想要去的的个数
		ArrayList<Integer> tempArr = new ArrayList<>();
		scanner.nextLine();
		int temp;
		int count = 0;
		for(int i = 0;i<m;i++) {
			temp = scanner.nextInt();
			if(tempArr.contains(temp)) {
				count++;
				continue;
			}
			tempArr.add(temp);
		}
		scanner.close();
		int result = searchLeastTime(m-count, tempArr);
		System.out.println(result);
	}
	/**
	 * 查找最小旅行时间
	 * @param m 女友要旅游的景点数目
	 * @param visitNos 女友要旅游的景点的序号
	 * @return 返回最小的结果
	 */
	public static int searchLeastTime(int m,ArrayList<Integer> visitNos) {
		int[] min = new int[1];
		min[0] = Integer.MAX_VALUE;
		dfs(0, m, visitNos, new int[m], 0, 0,min);
		return min[0];
	}
	/**
	 * 深度优先遍历,来进行经典的全排列并将所有的路长累加与最小值进行比较
	 * @param visitedCount 已经游览的经典的总数
	 * @param m 女友要游览的景点的总数
	 * @param visitNos 女友要游览的景点的序号的集合
	 * @param visited 每个景点是否已经被游览
	 * @param i 上一个游览的景点
	 * @param distance 已经游览的景点所走过的路程
	 * @param min 已经查找到的最小值
	 */
	public static void dfs(int visitedCount,int m,ArrayList<Integer> visitNos,int[] visited,int i,int distance,int[] min) {
		if(distance>=min[0])//剪枝,把不需要继续查找的节点全部省略,避免不必要的入栈
			return;	
		if(visitedCount>=m) {
			min[0] = distance;
			return;
		}
		for(int j = 0;j<m;j++) {
			if(visited[j]==0) {
				visited[j] = -1;
				int no = visitNos.get(j);
				dfs(visitedCount+1, m, visitNos, visited, no,distance+Util.getDistance(i, no),min);
				visited[j] = 0;
			}
		}
	}
}
/**
 * 工具类
 * @author Headphone_Sang
 *
 */
class Util{
	public static int[][] distances;
	public static int getDistance(int startLoc,int endLoc) {
		return distances[startLoc][endLoc];
	}
	public static void setDistances(int[][] distances) {
		Util.distances = distances;
		floyd();
	}
	/**
	 * 重新将数组排列,查找每个点到其他点的最短路径
	 * @param waitArray 未优化的节点
	 */
	public static void floyd() {
		int n = distances.length-1;
		for(int k=1;k<=n;++k){
			for(int i=1;i<=n;++i){
				for(int j=1;j<=n;++j){
					distances[i][j] = Math.min(distances[i][j],distances[i][k]+distances[k][j]);
				}
			}
		}
	}
}

弗罗伊德算法

:https://www.cnblogs.com/wangyuliang/p/9216365.html