Java 实现最优路径查找算法(伪Leetcode路径查找算法)

Java 实现最优路径查找算法(伪Leetcode路径查找算法)

今天忙里偷闲写了下关于Leetcode里面的路径查找相关算法，题目在下面的链接，这个题目和它前面的62题是连在一起的，但是这个题目有一个规定是，只能向右和向下查找，这里就有很大的可操作性了，本文是基于四个方向都可以移动来实现的，并且没有规定死开始位置和目标位置。
这里说明一下，这个算法的主要采用的是递归的实现，但是放到Leetcode里面时间复杂度是过不了的，如果有更好的实现思路请私信或者留言给我，算法中有可以改进的地方，也请留言告知，谢谢！
这里发一下题目的链接：
https://leetcode.com/problems/unique-paths-ii/

PS:这个算法不是完全按照leetcode里面的题目，Leetcode里面是规定是只能向右和向下，本文算法实现是没有做规定的.

实现方法：

动态规划算法

实现说明：

• 动态规划算法实现 两个条件：1、递归方案，2、边界条件
  递归方案：位置点的遍历；
  边界条件：最终目的点和当前遍历的路径深度是否大于查找到的路径的深度；下一个位置点是否是障碍物点或者是否已经同遍历层级遍历过。

• 该算法是找出所有的路径，在这些路径中可以找到最优解，并且最优解有可能不止一个。

• 在有第一条路径的时候，获取路径的长度。 然后在递归是可以判断当前路径的长度，如果已经大于已经有结果的最小路径，则直接回退即可，不需要遍历。

---

实现代码

代码里面是有相应的注释，就不过多解释了

public class Solution {
    // 结果容器
    private ArrayList<ArrayList<Point>> resultList = new ArrayList<ArrayList<Point>>();
    // 已经有路径的步数大小，如果大于这个步数就不用在递归了，肯定不是最优解
    private int alreadyPath = -1;

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        return uniquePathsWithObstacles(obstacleGrid, 0, 0,
                obstacleGrid.length - 1, obstacleGrid[0].length - 1);
    }

    private int uniquePathsWithObstacles(int[][] obstacleGrid, int startX,
            int startY, int endX, int endY) {
        Point[] pointArray = constructPointArray(obstacleGrid);
        if (pointArray != null && pointArray.length == 1
                && pointArray[0].value == 0) {
            return 1;
        }
        if (pointArray[startY + startX * obstacleGrid[0].length].value == 1
                || pointArray[endY + endX * obstacleGrid[0].length].value == 1) {
            return 0;
        }

        ArrayList<Point> list = new ArrayList<Point>();
        list.add(pointArray[startY + startX * obstacleGrid[0].length]);
        pointArray[startY + startX * obstacleGrid[0].length].IsCheck = true;
        caclPath(pointArray, pointArray[startY + startX
                * obstacleGrid[0].length], pointArray[endY + endX
                * obstacleGrid[0].length], list, obstacleGrid);
        return resultList.size();
    }

    private void caclPath(Point[] pointArray, Point currentPoint,
            Point targetPoint, ArrayList<Point> pointList, int[][] obstacleGrid) {
        if (alreadyPath != -1 && alreadyPath < pointList.size()) {
            return;
        }
        if (currentPoint == targetPoint) {
            ArrayList<Point> tempList = (ArrayList<Point>) pointList.clone();
            if (tempList.size() < alreadyPath) {
                resultList = new ArrayList<ArrayList<Point>>();
            }
            alreadyPath = tempList.size();
            resultList.add(tempList);
            currentPoint.IsCheck = false;
            return;
        } else {
            ArrayList<Point> pointArrayTemp = currentPoint.getAroundPoint(
                    pointArray, obstacleGrid, targetPoint);
            for (int i = 0; i < pointArrayTemp.size(); ++i) {
                pointList.add(pointArrayTemp.get(i));
                pointArrayTemp.get(i).IsCheck = true;
                caclPath(pointArray, pointArrayTemp.get(i), targetPoint,
                        pointList, obstacleGrid);
                pointArrayTemp.get(i).IsCheck = false;
                pointList.remove(pointArrayTemp.get(i));
            }
        }

    }

    /**
     * 组成点对象
     * 
     * @param obstacleGrid
     * @return
     */
    private Point[] constructPointArray(int[][] obstacleGrid) {
        Point[] arrayPoint = new Point[obstacleGrid.length
                * obstacleGrid[0].length];
        Point point = null;
        for (int i = 0; i < obstacleGrid.length; ++i) {
            for (int k = 0; k < obstacleGrid[0].length; ++k) {
                point = new Point();
                point.X = i;
                point.Y = k;
                point.IsCheck = false;
                point.value = obstacleGrid[i][k];
                arrayPoint[k + i * obstacleGrid[0].length] = point;
            }
        }
        return arrayPoint;
    }

    private class Point {
        public int X;
        public int Y;
        public boolean IsCheck;
        public int value;

        /**
         * 获取某个点接下来可走的位置
         * 
         * @param pointArray
         * @param obstacleGrid
         * @param targetPoint
         * @return
         */
        private ArrayList<Point> getAroundPoint(Point[] pointArray,
                int[][] obstacleGrid, final Point targetPoint) {
            Point original = this;
            ArrayList<Point> arraylist = new ArrayList<Point>();
            Point point = null;
            // 上
            if (original.X - 1 >= 0
                    && pointArray[(original.X - 1) * obstacleGrid[0].length
                            + original.Y].value != 1
                    && !pointArray[(original.X - 1) * obstacleGrid[0].length
                            + original.Y].IsCheck) {
                // 说明点可以走
                point = pointArray[(original.X - 1) * obstacleGrid[0].length
                        + original.Y];
                arraylist.add(point);
            }
            // 下
            if (original.X + 1 < obstacleGrid.length
                    && pointArray[(original.X + 1) * obstacleGrid[0].length
                            + original.Y].value != 1
                    && !pointArray[(original.X + 1) * obstacleGrid[0].length
                            + original.Y].IsCheck) {
                // 说明点可以走
                point = pointArray[(original.X + 1) * obstacleGrid[0].length
                        + original.Y];
                arraylist.add(point);
            }
            // 左
            if (original.Y - 1 >= 0
                    && pointArray[(original.X) * obstacleGrid[0].length
                            + original.Y - 1].value != 1
                    && !pointArray[(original.X) * obstacleGrid[0].length
                            + original.Y - 1].IsCheck) {
                // 说明点可以走
                point = pointArray[(original.X) * obstacleGrid[0].length
                        + original.Y - 1];
                arraylist.add(point);
            }
            // 右
            if (original.Y + 1 < obstacleGrid[0].length
                    && pointArray[(original.X) * obstacleGrid[0].length
                            + original.Y + 1].value != 1
                    && !pointArray[(original.X) * obstacleGrid[0].length
                            + original.Y + 1].IsCheck) {
                // 说明点可以走
                point = pointArray[(original.X) * obstacleGrid[0].length
                        + original.Y + 1];
                arraylist.add(point);
            }
            return arraylist;
        }
    }
}

总结

   这个算法是我认为最有意思的一个算法，它可以做路径查找的小游戏，在对战类的游戏中有很大的帮助，本文的缺陷是，递归方案使得时间耗时严重，后续会继续对其进行优化，有好的思路请留言告知。