Java算法--寻路

标签：

题目：

要求用户输入一个值n作为一个n*n的矩阵大小，然后用户输入n行，每行有n个字符，每个字符用空格隔开，其中字符“A”表示起点，字符“B”表示终点，中间寻路有要求，如果当前字符是“+”则下一步必须是字符“-”或者字符“B”，如果当前字符是“-”则下一步必须是字符“+”或者字符“B”，如果当前字符是“A”则下一步是字符“+”字符“-”字符“B”都行。不考虑用户输入的其他字符，只有“+”“-”“B”，然后输出结果，能到达的最小的步数。

代码：

import java.util.ArrayList;
import java.util.Scanner;

public class Main{
	
	//矩阵的大小
	static int n;
	//用于记录是否走到了终点，true表示到了，false表示没有到，默认false
	static boolean flag = false;
	//用于存放所有的结果
	static ArrayList<Integer> list = new ArrayList<Integer>();
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		sc.nextLine();
		
		String[][] map = Produce();
		
		//测试代码
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
		
		//得到"A"的坐标，"B"的坐标
		int[] a = Local(map, "A");
		int[] b = Local(map, "B");
		
		//测试坐标是否正确
		System.out.println(a[0] + "   " + a[1]);
		System.out.println(b[0] + "   " + b[1]);
		
		//开始移动
		Move(map, a, b, 0);
		
		System.out.println("=========================");
		
		if(list.size() < 1){
			System.out.println("没有找到路径");
		}
		else{
			int mix = list.get(0);
			for(int i = 1; i < list.size(); i++){
				if(mix > list.get(i)){
					mix = list.get(i);
				}
			}
			System.out.println("最小路径为：" + mix);
		}
		
		//测试结束标志
		System.out.println("end！");
	}
	
	private static void Move(String[][] m, int[] a, int[] b, int s) {
		//用于记录走过的步数
		int sum = s;		
		String[][] map = m;
		//表示当前坐标
		int[] local = a;
		//表示终点坐标
		int[] end = b;
		
		MoveUp(map, local, end, sum);
		System.out.println(flag);
		//判断上一步是否到达了终点
		if(flag){
			//加入List集合，然后初始化，接着其他方案
			list.add(sum+1);
			flag = false;
		}
		
		//重新赋值
		sum = s;		
		map = m;
		local = a;
		end = b;			
		MoveRight(map, local, end, sum);
		System.out.println(flag);
		if(flag){
			//加入List集合，然后初始化，接着其他方案
			list.add(sum+1);
			flag = false;
		}
		
		//重新赋值
		sum = s;		
		map = m;
		local = a;
		end = b;
		MoveDown(map, local, end, sum);
		System.out.println(flag);
		if(flag){
			//加入List集合，然后初始化，接着其他方案
			list.add(sum+1);
			flag = false;
		}
		
		//重新赋值
		sum = s;		
		map = m;
		local = a;
		end = b;
		MoveLeft(map, local, end, sum);
		System.out.println(flag);
		if(flag){
			//加入List集合，然后初始化，接着其他方案
			list.add(sum+1);
			flag = false;
		}
		
	}

	private static void MoveLeft(String[][] map, int[] local, int[] end, int sum) {
//		//重新定义，用于保护现场，避免下一次走错
//		String[][] map = m;
//		int[] local = a;
//		int[] end = b;
//		int sum = s;
		
		//首先判断当前的坐标能不能向左移动
		if(local[1] != 0){
			//判断是否到了终点
			if((local[0] == end[0]) && (local[1]-1 == end[1])){
				//设置到达了终点
				flag = true;
//				return;
			}
			else{
				if(map[local[0]][local[1]].equals("A")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[1]--;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("+") && 
						map[local[0]][local[1]-1].equals("-")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[1]--;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("-") && 
						map[local[0]][local[1]-1].equals("+")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[1]--;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
			}
		}
		
	}

	private static void MoveDown(String[][] map, int[] local, int[] end, int sum) {
//		//重新定义，用于保护现场，避免下一次走错
//		String[][] map = m;
//		int[] local = a;
//		int[] end = b; 
//		int sum = s;
		
		//首先判断当前的坐标能不能向下移动
		if(local[0] != n-1){
			//判断是否到了终点
			if((local[0]+1 == end[0]) && (local[1] == end[1])){
				//设置到达了终点
				flag = true;
				return;
			}
			else{
				if(map[local[0]][local[1]].equals("A")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[0]++;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("+") && 
						map[local[0]+1][local[1]].equals("-")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[0]++;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("-") && 
						map[local[0]+1][local[1]].equals("+")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[0]++;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
			}
		}
		
	}

	private static void MoveRight(String[][] map, int[] local, int[] end, int sum) {
//		//重新定义，用于保护现场，避免下一次走错
//		String[][] map = m;
//		int[] local = a;
//		int[] end = b; 
//		int sum = s;
		
		//首先判断当前的坐标能不能向右移动
		if(local[1] != n-1){
			//判断是否到了终点
			if((local[0] == end[0]) && (local[1]+1 == end[1])){
				//设置到达了终点
				flag = true;
				return;
			}
			else{
				if(map[local[0]][local[1]].equals("A")){
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[1]++;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("+") && 
						map[local[0]][local[1]+1].equals("-")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[1]++;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("-") && 
						map[local[0]][local[1]+1].equals("+")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[1]++;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
			}
		}
		
	}

	private static void MoveUp(String[][] map, int[] local, int[] end, int sum) {
		
//		//重新定义，用于保护现场，避免下一次走错
//		String[][] map = m;
//		int[] local = a;
//		int[] end = b; 
//		int sum = s;
		
		//首先判断当前的坐标能不能向上移动
		if(local[0] != 0){
			//判断是否到了终点
			if((local[0]-1 == end[0]) && (local[1] == end[1])){
				//设置到达了终点
				flag = true;
				return;
			}
			else{
				if(map[local[0]][local[1]].equals("A")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[0]--;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("+") && 
						map[local[0]-1][local[1]].equals("-")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[0]--;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
				else if(map[local[0]][local[1]].equals("-") && 
						map[local[0]-1][local[1]].equals("+")){
					//把当前位置置为空，避免下一次重复走
					map[local[0]][local[1]] = " ";
					//改变坐标
					local[0]--;
					sum++;//步数加1
					//调用Move函数，接着往下走
					Move(map, local, end, sum);
				}
			}
		}
		
	}

	//得到str的坐标
	private static int[] Local(String[][] map, String str) {
		int[] local = new int[2];
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				if(map[i][j].equals(str)){
					local[0] = i;
					local[1] = j;
					return local;
				}
			}
		}
		
		return local;
	}

	//产生一个n*n的阵列
	private static String[][] Produce(){
		Scanner sc = new Scanner(System.in);
		String[] m = new String[n];
		String[][] map = new String[n][n];
		
		//控制台输入
		for(int i = 0; i < n; i++){
			m[i] = sc.nextLine();
		}
		
		//对输入的数据进行转换成去掉空格的
		for(int i = 0; i < n; i++){
			map[i] = m[i].split(" ");
		}
		
		return map;
	}
}

Java算法--寻路

标签：

原文地址：http://blog.csdn.net/champly/article/details/46299549