今天在某個公司的筆試題目上做到了一個題目：
任意給定兩個正半軸座標點，求最短路徑。

因為短時間很難寫出動態規劃，而且自己對動態規劃的理解也不夠深刻。所以能想到的就是回溯。

首先：給定起點和終點，求最短路徑，一共有八個方向

如果每次都在原有矩陣上跑，開銷太大了，於是採用擷取範圍的思想，將起
點和終點作為新矩陣的頂點進行擷取，建立新矩陣，更新座標，然後在此基
礎上找一個最短路徑出來

package com.test;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Stack;
public
 
 class findShortWay {
    //定義從上開始，順時針跑八個方向
    private int rowStep[] = {-1,-1,0,1,1,1,0,-1};
    private int colStep[] = {0,1,1,1,0,-1,-1,-1};
    //方向對映關係
    private String stepMappint[] ={"U","UR","R","RD","D","LD","L","UL"}; 
    Stack<Integer> minStack = null;
    private int endX,endY;
    public
 
 static void main(String[] args) {
        new findShortWay().dispatcherMethod();
    }
    //字元轉數字 因為此公司是橫座標是字母
    //本程式碼沒有做輸入轉數字的處理
    public int char2Int(char c) throws IllegalArgumentException{
        if(c >= 'a' && c <= 'z'){
            return c-'a';
        }else if(c >= 'A' && c<= 'Z'
 
){
            return c-'A';
        }else{
            throw new IllegalArgumentException("輸入不是字母");
        }
    }
    //初始化
    private void init(int arr[][]){
        for(int i=0;i<arr.length;i++){
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = 0;
            }
        }
    }
    /**
     * 核心處理類（排程器）
     */
    public void dispatcherMethod(){
        int startX,startY;
        //輸入起始座標和結束座標
        Scanner in = new Scanner(System.in);
        startX=in.nextInt();
        startY=in.nextInt();
        endX=in.nextInt();
        endY=in.nextInt();
        //處理輸入異常
        if(startX==endX && startY==endY){
            System.out.println("原地不動");
            return;
        }else if(startX<0 || endX<0 || startY<0 || endY<0){
            System.out.println("輸入異常");
            return;
        }
        //構建最小矩陣
        int arr[][] = new int[Math.abs(startX-endX)+1][Math.abs(startY-endY)+1];
        init(arr);
        //更新座標
        int num = getMin(startX,endX);
        startX = subtrac(startX,num);
        endX = subtrac(endX,num);
        num = getMin(startY,endY);
        startY = subtrac(startY,num);
        endY = subtrac(endY,num);

        //定義中轉棧
        Stack<Integer> stack = new Stack<Integer>();
        horseRun(stack,arr,startX,startY);
        realShortWay();
    }
    private int getMin(int x,int y){
        return x>y?y:x;
    }
    private int subtrac(int x,int y){
        return x-y;
    }

    private void horseRun(Stack<Integer> stack,int arr[][],int startX,int startY){
        arr[startX][startY]=1;
        //遍歷八個需要走的路徑
        for(int i=0;i<8;i++){
            //試步操作
            startX +=rowStep[i];
            startY +=colStep[i];
            //判斷是否可以走
                if(canWalk(arr,startX,startY)){
                    //每次符合的壓棧
                    stack.push(i);
                    //判斷是否到終點
                    if(startX==endX && startY==endY){
                        Stack<Integer> newStack = new Stack<Integer>();
                        newStack.addAll(stack);
                        //判斷是否是第一次找到路徑，或者是否比最短路徑短
                        if(minStack==null || stack.size()<minStack.size()){
                            //如果跑到終點，和最小棧的長度進行比較，更替
                            minStack = newStack;
                        }
                    }else{
                        horseRun(stack,arr,startX,startY);
                    }
                    stack.pop();
                }
            startX -=rowStep[i];
            startY -=colStep[i];
        }
        arr[startX][startY]=0;
    }
    //判斷本位置是否符合走步要求
    private boolean canWalk(int arr[][],int x,int y){
        if(x<0 || x>=arr.length || y<0 || y>=arr[x].length){
            return false;
        }
        if(arr[x][y] != 0){
            return false;
        }
        return true;
    }

    //語言描述真實最短路徑
    public void realShortWay(){
        if(minStack == null){
            System.out.println("迷宮沒有找到解");
            return;
        }
        Iterator<Integer> minStackIter = minStack.iterator();
        while(minStackIter.hasNext()){
            Integer i = minStackIter.next();
            System.out.print(stepMappint[i]+" ");
        }
        System.out.println();
    }
}

易錯點：
1. 建立新矩陣陣列的時候容易忘記終點和起點的座標做差會少計算一個單元的數值。
2. 因為是解演算法題，所以是沒有必要有提示語句的，此處是為了程式方便理解
3. 更新座標那裡，我還沒有想到更好的方法，如果有人想到了請給我發郵件[email protected]

程式真長。。還沒有加字元轉換功能呢~還是不符合題意。因為非常簡單，考察字串的拆分，大家可以自己嘗試實現