經典算法-（六）老鼠走迷宮

問題描述：

給定一個二維數組，數組中2表示牆壁，0表示通路，由此數組可展示為一個迷宮圖。給定入口位置和出口位置，判斷之間是否存在通路並顯示出走出迷宮的道路。

問題解答：

實際上是使用回溯算法求解該問題，就是在上下左右四個方向試探，倘若有路則走一步，在新的位置繼續在四個位置試探，並且對走過的路進行標記，倘若走到死胡同里，則退回上一步再來試探，以此類推，類似於圖的深度優先算法，使用遞歸來實現。

java實現：

package a;
import java.math.BigInteger;
import java.util.*;
public class Main{     
    public static  void main(String[] args)  {  
        System.out.println("請輸入一數來開始");
        Scanner cin = new Scanner(System.in);       
        while(cin.hasNext()){
          String n=cin.next();
          int[][] maze =new int [][] {
                {2,2,2,2,2,2,2,2,2},  
                {2,0,0,0,0,0,0,0,2},  
                {2,0,2,2,0,2,2,0,2},  
                {2,0,2,0,0,2,0,0,2},  
                {2,0,2,0,2,0,2,0,2},  
                {2,0,0,0,0,0,2,0,2},  
                {2,2,0,2,2,0,2,2,2},  
                {2,0,0,0,0,0,0,0,2},  
                {2,2,2,2,2,2,2,2,2}  
                };   
             xun(maze,1,1);
                
 }
        cin.close();      
    }
    static void xun(int[][] a,int i,int j) {
               a[i][j]=1; 
            if(i==7&&j==7)
            { System.out.println("打印一波：--------------");
            System.out.println();
                for(int m=0;m<9;m++) {
                    for (int n=0;n<9;n++) {
                        System.out.print(a[m][n]+" ");
                    }
                    System.out.println();
                }
            }
            if(a[i][j+1]==0) {
                  xun(a,i,j+1);
                }
            if(a[i+1][j]==0) {
                    xun(a,i+1,j);    
            }
             if(a[i-1][j]==0) {
                xun(a,i-1,j);    
            }
             if(a[i][j-1]==0) {
                xun(a,i,j-1);    
            }
             a[i][j]=0;
    }
}

運算結果：

點評：

現在的代碼是將所有可能的路線都打印出來了，稍微修改下可以實現打印一種結果，打印了所有的結果正是體現了回溯法可實現遍歷出所有可能的答案。

順便附上打印一種結果的實現代碼 ：

c++實現：

#include <stdio.h>
#include <stdlib.h>

int visit(int , int );

int maze[7][7] = {
    {2, 2, 2, 2, 2, 2, 2},
    {2, 0, 0, 0, 0, 0, 2},
    {2, 0, 2, 0, 2, 0, 2},
    {2, 0, 0, 2, 0, 2, 2},
    {2, 2, 0, 2, 0, 2, 2},
    {2, 0, 0, 0, 0, 0, 2},
    {2, 2, 2, 2, 2, 2, 2} 
};

int startI = 1, startJ = 1;
int endI = 5, endJ = 5;
int success = 0;

int main(void)
{
    int i, j;

    printf("顯示迷宮：\n");
    for(i = 0; i < 7; i++)
    {
        for(j = 0; j < 7; j++)
        {
            if(maze[i][j] == 2)
                printf("#");
            else
                printf(" ");
        }
        printf("\n");
    }
    
    if(visit(startI, startJ) == 0)
        printf("\n沒有找到出口!\n");
    else
    {
        printf("\n顯示路徑：\n");
        for(i = 0; i < 7; i++)
        {
            for(j = 0; j < 7; j++)
            {
                if(maze[i][j] == 2)
                    printf("#");
                else if(maze[i][j] == 1)
                    printf("1");
                else
                    printf(" ");
            }
            printf("\n");        
        }
    }
    return 0;
} 

int visit(int i, int j)
{
    maze[i][j] = 1;
    
    if(i == endI && j == endJ)
        success = 1;
        
    if(success != 1 && maze[i][j+1] == 0)
        visit(i, j+1); 
    if(success != 1 && maze[i+1][j] == 0)
        visit(i+1, j);
    if(success != 1 && maze[i][j-1] == 0)
        visit(i, j-1);
    if(success != 1 && maze[i-1][j] == 0)
        visit(i-1, j);
        
    if(success != 1)
        maze[i][j] = 0; 
    return success;
}