java算法-关于Java的走迷宫问题

问题描述

关于Java的走迷宫问题

题目是这样的:
用户输入一个值,生成一个n*n的矩阵,然后每个符号之间用空格隔开,要求从A到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("=========================");
    for(int i = 0; i < list.size(); i++){
        System.out.println(list.get(i));
    }

    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;
}

}

解决方案

http://www.cnblogs.com/rollenholt/archive/2011/08/23/2151202.html

时间: 2024-09-15 17:30:45

java算法-关于Java的走迷宫问题的相关文章

java算法-通过java计算最大收益值

问题描述 通过java计算最大收益值 x1,x2,x3分别代表三种营销产品,a1,a2,a3营销成功率,b1,b2,b3是三种产品的价值:假设a1=0.6%,b1=0.7%,c1=0.89%:b1=10,b2=20,b3=30 收益=x1*a1*b1+x2*a2*b2+x3*a3*b3 条件1:x1+x2+x3=110000(三种产品的营销数量为11万) 条件2:x1*a1+x2*a2+x3*a3>=500 (三种产品的营销成功数量大于500) 求收益的max值时x1,x2,x3的数值各为多少?

java算法-关于java List&amp;amp;lt;Map&amp;amp;gt; 排序的问题

问题描述 关于java List<Map> 排序的问题 具体看一下代码第一次调用该方法可以排序但第二次调用的时候他就根本没有调用里面的compare()这个方法了排序还是执行的上次的那个请问下这是什么问题? public static List<Map<String Object>> sortList(final String sortOrderfinal String sortNameList<Map<String Object>> list)

深搜算法实例:老鼠走迷宫(一)

这个是简单的深搜,应该输入深搜中抛砖型的,联系下代码,回顾一下深搜的思想. 本题的要求是,在开始点(1,1)和终点(5,5)放一只老鼠,让老鼠找到一条路径走出去(暂时不考虑最短路径),找到后输出路径. 最简单的想法就是对于上下左右四个进行刨根型的搜索,找到就返回输出,进入死胡同了就原路返回,找最近的有其他路径的点,继续搜索,知道找出为止. 下面是代码部分. #include <stdio.h> #include <stdlib.h> #define SUCCESS 1 #defin

最小生成树算法:Kruskal算法的Java实现

闲来无事,写个算法,最小生成树的Kruskal算法,相对比Prim算法实现起来麻烦一点点 package trees; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.PriorityQueue; import java.util.Set; /** * 最小生成树的Kruskal算法, * For a connected weighted graph G, a s

JAVA算法系列 快速排序

java算法系列之排序 手写快排 首先说一下什么是快排,比冒泡效率要高,快排的基本思路是首先找到一个基准元素,比如数组中最左边的那个位置,作为基准元素key,之后在最左边和最右边设立两个哨兵,i 和 j 之后,开始按住左哨兵(i),让右哨兵(j)往左走(j--),找到比key小的元素后,按住右哨兵(j),开始让左哨兵往右走(i++),直到找到比key大的元素,让i和j脚下的值互换,此时完成第一趟快排,之后开始按照这个思路进行while循环,跳出循环的条件很简单,就是当两个哨兵碰头了,就跳出循环,

Dijkstra算法(三) Java详解

迪杰斯特拉算法介绍 迪杰斯特拉(Dijkstra)算法是典型最短路径算法,用于计算一个节点到其他节点的最短路径. 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止. 基本思想 通过Dijkstra计算图G中的最短路径时,需要指定起点s(即从顶点s开始计算). 此外,引进两个集合S和U.S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度),而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离). 初始时,S中只有起点s:U中是除s之外的顶点,并且U中

Floyd算法(三) Java详解

弗洛伊德算法介绍 和Dijkstra算法一样,弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法.该算法名称以创始人之一.1978年图灵奖获得者.斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名. 基本思想 通过Floyd计算图G=(V,E)中各个顶点的最短路径时,需要引入一个矩阵S,矩阵S中的元素a[i][j]表示顶点i(第i个顶点)到顶点j(第j个顶点)的距离. 假设图G中顶点个数为N,则需要对矩阵S进行N次更新.初始时,矩阵S中顶点a[i][j]的距离为顶点i到顶点

链表-求助Java算法,这两个算法问题有Java代码实现

问题描述 求助Java算法,这两个算法问题有Java代码实现 从N个元素集合里面随机抽取M个元素(M<N). C/C++: void randomChoose(int*data, intn, int *result, int m); Java: void randomChoose(int data[], int result[]); 说明: 1.Data是待抽取的元素集合,n是data的长度,result是抽取的结果,m是结果集的长度. 2.同一个元素不能被反复抽取. 3.每个元素被抽取到的概率

JAVA算法实现图片透明化渐变

问题描述 JAVA算法实现图片透明化渐变 关于实现图像黑白的颜色渐变可以实现.用每行的红绿蓝都逐渐减少就能实现. 但是上面要求提供一个算法把传进来的图片覆盖一层从透明黑色的阴影逐渐变成透明的效果. 求指导~~ 要是能把源码发来就跟好了~~ 解决方案 源代码肯定是没有的,需要你自己实现. 图片,是什么格式的呢?BMP,还是 PNG? 要处理图片,你首先要能读到图片未处理前的每像素的数值吧,如果能读到,做黑白渐变只是简单的修改读到的 RGB 的数值. 透明黑色的阴影,如果是 PNG 格式,则可以通过