一时兴起，写了个寻路代码

看到一个面试题，是有关寻路的，于是想练练手，自己也写一个。

把地图坐标设计为二维数据，坐标点的值代表不同意义。

先上代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class FindLine {
    // 测试数据,0代表可通的路,1代表墙,5代表起点或终点
    public static int[][] map = { 
            { 0, 0, 0, 0, 0, 0 }, 
            { 0, 1, 0, 1, 0, 0 },
            { 0, 0, 5, 0, 1, 0 },
            { 0, 0, 0, 1, 0, 0 },
            { 0, 1, 1, 5, 0, 1 },
            { 0, 0, 1, 0, 0, 0 } };

    // 方向 = 0,1,2,3 上右下左
    public static int[][] move = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } }; // 上，右，下，左
    // 记录已经查询过路径
    public static int[][] used = { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 },
            { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 },
            { 0, 0, 0, 0, 0, 0 } };

    /**
     * @author Huang
     * @return void
     */

    public static void main(String[] args) {

        int[] o1 = { 2, 2 }; // 起点
        int[] o2 = { 4, 3 }; // 终点
        if (eq(o1, o2)) {
            used[o1[0]][o1[1]] = 1;
            runLineOld.add(o1);
            if (count(o1, o2)) {
                used[o2[0]][o2[1]] = 1;
                runLineOld.add(o2);
                reline();
                System.out.println();
                System.out.println("寻路记录的点(用2来表示)");
                for (int i = 0; i < used.length; i++) {
                    for (int j = 0; j < used[i].length; j++) {
                        System.out.print(used[i][j] + "  ");
                    }
                    System.out.println();
                }
                
                System.out.println("初始路径");
                for (int[] r : runLineOld) {
                    System.out.print("[" + r[0] + "," + r[1] + "],");
                }
                System.out.println();
                System.out.println("优化后路径");
                for (int[] r : runLineNew) {
                    System.out.print("[" + r[0] + "," + r[1] + "],");
                }
                
                
            }
        }

    }

    // 检查是否相等
    public static boolean eq(int[] o1, int[] o2) {
        return map[o1[0]][o1[1]] == map[o2[0]][o2[1]];
    }

    
    static List<int[]> runLineOld = new ArrayList<>(); // 初始路径
    static List<int[]> runLineNew = new ArrayList<>(); // 优化路径

    // 计算路径
    public static boolean count(int[] o1, int[] o2) {
        if (isNear(o1, o2)) {
            System.out.print("[" + o2[0] + "," + o2[1] + "],");
            return true; // yes
        }

        int[] line = findLine(o1);
        if (line.length == 0) {
            return false;// no ;
        }

        List<LineRate> lr = countRate(o1, line, o2);
        Collections.sort(lr, new Comparator<LineRate>() {
            @Override
            public int compare(LineRate o1, LineRate o2) {
                if (o1.getR() > o2.getR()) {
                    return 1;
                } else if (o1.getR() < o2.getR()) {
                    return -1;
                }
                return 0;
            }
        });

        boolean find = false;
        for (int i = 0; i < lr.size(); i++) {
            int[] ot = new int[2];
            ot[0] = o1[0] + move[lr.get(i).getF()][0];
            ot[1] = o1[1] + move[lr.get(i).getF()][1];
            if (used[ot[0]][ot[1]] == 1) {
                continue;
            }
            used[ot[0]][ot[1]] = 1;
            runLineOld.add(ot);
            System.out.print("[" + ot[0] + "," + ot[1] + "],");
            if (count(ot, o2)) {
                // yes
                find = true;
                break;
            } else {
                used[ot[0]][ot[1]] = 2;// 此路不通
                System.out.print("|");
                runLineOld.remove(runLineOld.size() - 1);
                continue;
            }
        }
        return find;

    }

    public static boolean isNear(int[] o1, int[] o2) {
        if (o1[0] == o2[0] && Math.abs(o1[1] - o2[1]) == 1) {
            return true;
        } else if (o1[1] == o2[1] && Math.abs(o1[0] - o2[0]) == 1) {
            return true;
        } else {
            return false;
        }
    }

    // 找出可用路径
    public static int[] findLine(int[] o1) {

        List<Integer> cl = new ArrayList<>();

        for (int i = 0; i < 4; i++) {
            if (checkUse(o1, i) == 1) {
                cl.add(i);
            }
        }
        int[] f = new int[cl.size()];
        for (int i = 0; i < f.length; i++) {
            f[i] = cl.get(i);
        }
        return f;

    }

    // 检查该位置是否可用,1是,0否
    public static int checkUse(int[] o1, int f) {

        int xt1 = o1[0] + move[f][0];
        int yt1 = o1[1] + move[f][1];
        if (xt1 > -1 && xt1 < map[0].length && yt1 > -1 && yt1 < map.length
                && used[xt1][yt1] == 0) {
            if (map[xt1][yt1] == 0) {
                return 1;
            }
        }
        return 0;
    }

    // 计算权重
    public static List<LineRate> countRate(int[] ot, int[] f, int[] o2) {

        // r = g + h , g = 10 , h = |x2 - x1 |+ |y2 - y1|
        int g = 10;
        List<LineRate> list = new ArrayList<>();
        for (int i = 0; i < f.length; i++) {
            int otx = ot[0] + move[f[i]][0];
            int oty = ot[1] + move[f[i]][1];
            int r = Math.abs(o2[0] - otx) + Math.abs(o2[1] - oty) + g;
            LineRate lr = new LineRate();
            lr.setF(f[i]);
            lr.setR(r);
            list.add(lr);
        }
        return list;

    }

    // 线路与权重
    static class LineRate {
        int f;
        int r;

        public int getF() {
            return f;
        }

        public void setF(int f) {
            this.f = f;
        }

        public int getR() {
            return r;
        }

        public void setR(int r) {
            this.r = r;
        }
    }

    // 修正路径
    public static void reline() {

        List<Integer> record = new ArrayList<>();
        int len = runLineOld.size() - 1;
        int i = 0;
        int j = len;
        record.add(i);
        runLineNew.add(runLineOld.get(i));
        while (true) {
            while (i < j && !isNear(runLineOld.get(i), runLineOld.get(j))) {
                j--;
            }
            if (i < j) { // 找到可优化的路径
                i = j;
                runLineNew.add(runLineOld.get(i));
                j = len;
            } else if (i == len) {
                break;
            } else if (i == j) {
                i++;
            }
        }
    }

}

运行结果：

[2,3],|[3,2],[3,1],[2,1],[2,0],[3,0],[4,0],[5,0],[5,1],||||[1,0],[0,0],[0,1],[0,2],[0,3],[0,4],[1,4],[1,5],[2,5],[3,5],[3,4],[4,4],[4,3],
寻路记录的点(2寻过的路且不通，1寻找的路径,0墙)
1  1  1  1  1  0 
1  0  0  0  1  1 
1  1  1  2  0  1 
2  1  1  0  1  1 
2  0  0  1  1  0 
2  2  0  0  0  0 
初始路径
[2,2],[3,2],[3,1],[2,1],[2,0],[1,0],[0,0],[0,1],[0,2],[0,3],[0,4],[1,4],[1,5],[2,5],[3,5],[3,4],[4,4],[4,3],
优化后路径
[2,2],[2,1],[2,0],[1,0],[0,0],[0,1],[0,2],[0,3],[0,4],[1,4],[1,5],[2,5],[3,5],[3,4],[4,4],[4,3],

思路：

深度优先寻路，再采用A*算法中的权重来优先选择格子，遇到墙时，就选择权重第二小的，依此进行....

由于是深度优先，得到的路径并不是最估的，然后再进行路径优化，得到最后的结果。

PS：深度优先，再优化路径，这感觉在墙比较多时会高效些，广度优先，我估计不用再优化路径这步操作了，但计算量会多很多。