經典算法大全51例——5&6.老鼠走迷官

算法目錄合集

地址

   算法目錄合集java

說明

  該地址指向全部由本人本身所經歷的算法習題(也有可能僅僅是一個入門的案例或者是經典案例),僅僅爲我作過並且比較有意思的,也許還會有一些我本身想出來的,出於興趣寫在這裏,具體格式我會在下面列明,總目錄也會在這裏出現,方便查閱以及本身進行復習回顧。算法

題目以及我的題解

說明

  這個在原文中是兩個題,我把他們綜合一下,做爲一個題展示給你們,爲了避免水貼嘛,看看我有多好啊🤗🤗🤗🤗哈哈哈。測試

題目

  咱們在二維陣列中使用2表示迷宮牆壁,使用1來表示老鼠的行走路徑,試以程式求出由入口至出口的路徑。
  思考:因爲迷宮的設計,老鼠走迷宮的入口至出口路徑可能不僅一條,如何求出全部的路徑呢?
例如:

spa

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

  特別說明.net

  第二個問題(思考部分)其實在《經典算法大全51例》裏面是第六道題,我看類型太過類似了,簡直就是一道題,因此我合在一塊兒了設計

原理分析

  其實作這題的思路卻是很是簡單的,你們想想,小時候本身有沒有玩兒過鏡子迷宮,就算沒有,也總玩兒紙上迷宮吧,想想被迷宮支配的恐懼!
escape
  你們回憶一下,面對迷宮是怎麼操做的?有人就會懟我了「廢話,還能咋咋操做,固然是哪兒有路往哪兒走啦」,話說的很對,我接受被懟,那麼你怎麼知道哪兒有路呢?有人又該懟我了「那你要眼睛出氣兒的啊」,嗯,我還接受,下面我又要問了:「題目中的老鼠,你怎麼給他賦予一雙智慧的眼睛呢?」

3d

  其實很簡單,就像第一句懟個人話:哪兒有路往哪兒走,那麼在程序中怎麼讓老鼠擁有眼睛呢?那很簡單,假如如今老鼠隨便站一個位置(這個位置確定是0啊,別跟我犟,哼哼😕),那麼咱們就去看看這個位置的上下左右是否是能夠通行(0是空地,2是牆壁),若是是0,那麼就可讓老鼠到這兒,而且再次進行是否能夠通行的判斷,那麼問題來了,萬一這隻老鼠反覆橫跳😕怎麼辦?就像這種矩陣:
daedRoad
  其實避免這種狀況的方法題目裏也已經給咱們了:使用1來表示老鼠的行走路徑。那麼咱們只須要判斷周圍是否是0就能夠了,這樣就能夠在最後顯示出來路徑了。

rest

問題①

原理

  咱們先來作第一問:只尋找一條路:code

  爲了方便展現,咱們先畫出來地圖原圖來把矩陣進行展現,而後調用老鼠行走的方法,最後繪製帶有路徑的地圖,這就是主方法:blog

//打印地圖
        for (int m = 0; m < maze.length; m++) { 
            for (int n = 0; n < maze[m].length; n++) { 
                switch (maze[m][n]) { 
                    //表明路
                    case 0:
                        System.out.print(" ");
                        break;
                    //表明牆
                    case 2:
                        System.out.print("📦");
                        break;
                    default:
                        break;
                }
            }
            System.out.println();
        }

        //開始尋找
        seekOnce(maze, startRow, startRank);
        System.out.println("=====================");
        //打印路徑
        if (success) { 
            for (int m = 0; m < maze.length; m++) { 
                for (int n = 0; n < maze[m].length; n++) { 
                    switch (maze[m][n]) { 
                        //表明路
                        case 0:
                            System.out.print(" ");
                            break;
                        //表明老鼠走的路
                        case 1:
                            System.out.print("🐾");
                            break;
                        //表明牆
                        case 2:
                            System.out.print("📦");
                            break;
                        default:
                            break;
                    }
                }
                System.out.println();
            }
        } else { 
            System.out.println("找不到出口");
        }
    }

  而對於老鼠行走的方法,咱們在原理分析的時候已經分析過了,首先把老鼠走過的位置從0變成1(🐶:「這是否是和我撒尿一個道理?」,🙄:「我呸!」),而後繼續找上下左右哪裏有0,有0就過去,把他變成1(🎃感受怪怪的??🎃):

maze[i][j] = 1;
		if (!success && maze[i][j + 1] == 0) { 
            seekOnce(maze, i, j + 1);
        }
        if (!success && maze[i + 1][j] == 0) { 
            seekOnce(maze, i + 1, j);
        }
        if (!success && maze[i][j - 1] == 0) { 
            seekOnce(maze, i, j - 1);
        }
        if (!success && maze[i - 1][j] == 0) { 
            seekOnce(maze, i - 1, j);
        }

  沒0就不用繼續討論了;假如某條分支A,調用了四個方向,發現四周不是走過的路(1)就是牆(2),那麼就再把這條分支變回0就好了:

if (!success) { 
            maze[i][j] = 0;
        }

  一直等老鼠到達了咱們指定的終點,那麼就把標識是否完成迷宮的標識符變成true,那麼就成功了,若是遍歷完了全部格子,咱們的小老鼠依舊沒有到達指定的重點,那麼標識符仍是false,最後咱們只須要將標識符返回,就能夠判斷是否有這麼一條路徑可讓老鼠達到終點了:

if (success) { 
	//打印地圖
} else { 
	System.out.println("找不到出口");
}

  能夠注意一下,由於結束的條件有兩種,一個是找完全部的路,而後發現沒有出口,結束了整個流程,另外一種就是已經找到了重點,那這個時候何須繼續調用方法呢,因此每一條我都增長了判斷條件:

if (success)

代碼實現——Java

package com.interest;

/** * com.interest * * @author g55zhw * @create 2020-09-30-20-54 */

public class MouseFindOnce { 
    static int startRow = 1, startRank = 1;
    static int endRow = 7, endRank = 7;
    static int count = 1;
    static boolean success = false;
    static 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}
    };

    public static void main(String[] args) { 
        //打印地圖
        for (int m = 0; m < maze.length; m++) { 
            for (int n = 0; n < maze[m].length; n++) { 
                switch (maze[m][n]) { 
                    //表明路
                    case 0:
                        System.out.print(" ");
                        break;
                    //表明牆
                    case 2:
                        System.out.print("📦");
                        break;
                    default:
                        break;
                }
            }
            System.out.println();
        }

        //開始尋找
        seekOnce(maze, startRow, startRank);
        System.out.println("=====================");
        //打印路徑
        if (success) { 
            for (int m = 0; m < maze.length; m++) { 
                for (int n = 0; n < maze[m].length; n++) { 
                    switch (maze[m][n]) { 
                        //表明路
                        case 0:
                            System.out.print(" ");
                            break;
                        //表明老鼠走的路
                        case 1:
                            System.out.print("🐾");
                            break;
                        //表明牆
                        case 2:
                            System.out.print("📦");
                            break;
                        default:
                            break;
                    }
                }
                System.out.println();
            }
        } else { 
            System.out.println("找不到出口");
        }
    }

    static boolean seekOnce(int[][] maze, int i, int j) { 
        System.out.println("(" + i + "," + j + ")" + count);
        count++;
        maze[i][j] = 1;
        if (i == endRow && j == endRank) { 
            success = true;
        }
        if (!success && maze[i][j + 1] == 0) { 
            seekOnce(maze, i, j + 1);
        }
        if (!success && maze[i + 1][j] == 0) { 
            seekOnce(maze, i + 1, j);
        }
        if (!success && maze[i][j - 1] == 0) { 
            seekOnce(maze, i, j - 1);
        }
        if (!success && maze[i - 1][j] == 0) { 
            seekOnce(maze, i - 1, j);
        }
        if (!success) { 
            maze[i][j] = 0;
        }
        return success;
    }
}

結果演示
  因爲字符的間距問題,空格在這兒顯示會有點兒問題,你們勉強能看~~~

📦📦📦📦📦📦📦📦📦
📦               📦
📦  📦📦  📦📦   📦
📦  📦    📦     📦
📦  📦  📦  📦  📦
📦          📦  📦
📦📦  📦📦  📦📦📦
📦            📦
📦📦📦📦📦📦📦📦📦
(1,1)1
(1,2)2
(1,3)3
(1,4)4
(1,5)5
(1,6)6
(1,7)7
(2,7)8
(3,7)9
(4,7)10
(5,7)11
(3,6)12
(2,4)13
(3,4)14
(3,3)15
(4,3)16
(5,3)17
(5,4)18
(5,5)19
(6,5)20
(7,5)21
(7,6)22
(7,7)23
📦📦📦📦📦📦📦📦📦
📦🐾🐾🐾🐾    📦
📦 📦📦🐾📦📦   📦
📦 📦🐾🐾📦   📦
📦 📦🐾📦 📦  📦
📦  🐾🐾🐾📦  📦
📦📦  📦📦🐾📦📦📦
📦          🐾🐾🐾📦
📦📦📦📦📦📦📦📦📦

  你們能夠看到,除了打印了地圖我還增長了一條打印內容,那就是如今進行的地點以及第幾回調用方法,你們把上下左右的順序換一換,這個值也會發生變化,好比先判斷向下走:

if (!success && maze[i + 1][j] == 0) { 
            seekOnce(maze, i + 1, j);
        }
		if (!success && maze[i][j + 1] == 0) { 
            seekOnce(maze, i, j + 1);
        }
        if (!success && maze[i - 1][j] == 0) { 
            seekOnce(maze, i - 1, j);
        }
        if (!success && maze[i][j - 1] == 0) { 
            seekOnce(maze, i, j - 1);
        }

  這樣的話,那路線就是向下爲主了,你們能夠本身試一試。

問題②

原理

  第二個問題其實通過了第一題的洗禮,你們應該很容易就接受了,我就不一步一步說步驟了,說一個大體的過程,而後在代碼裏放一串「神祕代碼」,你們天然就能夠理解了:

  ①首先把成功標識符去掉,這樣才能讓老鼠就算成功到達了一次重點也不至於終結整個方法;

  重要:

  ②(這段解釋一樣實用於問題一,可是在這裏更容易理解,我才放在這兒了)我增長了這麼一條語句來幫助你們理解,其實並非老鼠在走,走到終點或者走不動了纔回頭,而是咱們認爲地去調方法,由於若是真的是老鼠在走,那麼就不會一會兒執行100屢次纔會終止了,真正的狀況是:咱們每次調用方法的時候,都是至關於施行了一次「影分身」,假如老鼠站的位置如今上左不能走,那麼咱們就讓他去下和右,這樣就分了一次身;去右邊那個假如又遇到分叉了,再分身……剩下的就是和問題一的執行相似了,有路到終點,那麼1就是1,0就是0,若是這個分支到不了終點,那麼0仍是0,1也是0;

System.out.println("========第" + count + "次調用seekForever方法========");
count++;

代碼實現——Java

package com.interest;

/** * com.interest * * @author g55zhw * @create 2020-09-30-21-14 */

public class MouseFindAll { 
    static int startRow = 1, startRank = 1;
    static int endRow = 7, endRank = 7;
    static int count = 1;
    static int[][] mazeTitle = 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}
    };

    public static void main(String[] args) { 
        seekForever(mazeTitle, startRow, startRank);
    }

    static void seekForever(int[][] maze, int i, int j) { 
        //首先賦值爲1,表示這塊地板我已經來了
        maze[i][j] = 1;
        System.out.println("========第" + count + "次調用seekForever方法========");
		count++;
		//打印地圖
        if (i == endRow && j == endRank) { 
            for (int m = 0; m < maze.length; m++) { 
                for (int n = 0; n < maze[m].length; n++) { 
                    switch (maze[m][n]) { 
                        //表明路
                        case 0:
                            System.out.print(" ");
                            break;
                        //表明老鼠走的路
                        case 1:
                            System.out.print("🐾");
                            break;
                        //表明牆
                        case 2:
                            System.out.print("📦");
                            break;
                        default:
                            break;
                    }
                }
                System.out.println();
            }
        }else { 
            System.out.println("尚未到終點");
        }

        //如下四個方向,有任何一個方向是路(0)的話,就能夠通行(調用seekForever方法);
        if (maze[i][j + 1] == 0) { 
            seekForever(maze, i, j + 1);
        }
        if (maze[i + 1][j] == 0) { 
            seekForever(maze, i + 1, j);
        }
        if (maze[i - 1][j] == 0) { 
            seekForever(maze, i - 1, j);
        }
        if (maze[i][j - 1] == 0) { 
            seekForever(maze, i, j - 1);
        }
        //四個方向都沒有路的話就把已經踩過的地板換回0,僞裝沒來過→_→
        maze[i][j] = 0;
    }
}

結果演示

========1次調用seekForever方法========
尚未到終點
========2次調用seekForever方法========
尚未到終點
========3次調用seekForever方法========
尚未到終點
========4次調用seekForever方法========
尚未到終點
========5次調用seekForever方法========
尚未到終點
========6次調用seekForever方法========
尚未到終點
========7次調用seekForever方法========
尚未到終點
========8次調用seekForever方法========
尚未到終點
========9次調用seekForever方法========
尚未到終點
========10次調用seekForever方法========
尚未到終點
========11次調用seekForever方法========
尚未到終點
========12次調用seekForever方法========
尚未到終點
========13次調用seekForever方法========
尚未到終點
========14次調用seekForever方法========
尚未到終點
========15次調用seekForever方法========
尚未到終點
========16次調用seekForever方法========
尚未到終點
========17次調用seekForever方法========
尚未到終點
========18次調用seekForever方法========
尚未到終點
========19次調用seekForever方法========
尚未到終點
========20次調用seekForever方法========
尚未到終點
========21次調用seekForever方法========
尚未到終點
========22次調用seekForever方法========
尚未到終點
========23次調用seekForever方法========
📦📦📦📦📦📦📦📦📦
📦🐾🐾🐾🐾     📦
📦  📦📦🐾📦📦  📦
📦  📦🐾🐾📦    📦
📦  📦🐾📦 📦   📦
📦   🐾🐾🐾📦   📦
📦📦  📦📦🐾📦📦📦
📦       🐾🐾🐾📦
📦📦📦📦📦📦📦📦📦
========24次調用seekForever方法========
尚未到終點
========25次調用seekForever方法========
尚未到終點
========26次調用seekForever方法========
尚未到終點
========27次調用seekForever方法========
尚未到終點
========28次調用seekForever方法========
尚未到終點
========29次調用seekForever方法========
尚未到終點
========30次調用seekForever方法========
尚未到終點
========31次調用seekForever方法========
尚未到終點
========32次調用seekForever方法========
尚未到終點
========33次調用seekForever方法========
尚未到終點
========34次調用seekForever方法========
尚未到終點
========35次調用seekForever方法========
尚未到終點
========36次調用seekForever方法========
尚未到終點
========37次調用seekForever方法========
尚未到終點
========38次調用seekForever方法========
尚未到終點
========39次調用seekForever方法========
尚未到終點
========40次調用seekForever方法========
尚未到終點
========41次調用seekForever方法========
尚未到終點
========42次調用seekForever方法========
📦📦📦📦📦📦📦📦📦
📦🐾🐾🐾🐾     📦
📦 📦📦🐾📦📦  📦
📦 📦🐾🐾📦     📦
📦 📦🐾📦 📦   📦
📦 🐾🐾   📦   📦
📦📦🐾📦📦 📦📦📦
📦  🐾🐾🐾🐾🐾🐾📦
📦📦📦📦📦📦📦📦📦
========43次調用seekForever方法========
尚未到終點
========44次調用seekForever方法========
尚未到終點
========45次調用seekForever方法========
尚未到終點
========46次調用seekForever方法========
尚未到終點
========47次調用seekForever方法========
尚未到終點
========48次調用seekForever方法========
尚未到終點
========49次調用seekForever方法========
尚未到終點
========50次調用seekForever方法========
尚未到終點
========51次調用seekForever方法========
尚未到終點
========52次調用seekForever方法========
尚未到終點
========53次調用seekForever方法========
尚未到終點
========54次調用seekForever方法========
尚未到終點
========55次調用seekForever方法========
尚未到終點
========56次調用seekForever方法========
尚未到終點
========57次調用seekForever方法========
尚未到終點
========58次調用seekForever方法========
尚未到終點
========59次調用seekForever方法========
尚未到終點
========60次調用seekForever方法========
尚未到終點
========61次調用seekForever方法========
尚未到終點
========62次調用seekForever方法========
尚未到終點
========63次調用seekForever方法========
📦📦📦📦📦📦📦📦📦
📦🐾          📦
📦🐾📦📦 📦📦  📦
📦🐾📦   📦   📦
📦🐾📦  📦 📦 📦
📦🐾🐾🐾🐾🐾📦 📦
📦📦 📦📦🐾📦📦📦
📦        🐾🐾🐾📦
📦📦📦📦📦📦📦📦📦
========64次調用seekForever方法========
尚未到終點
========65次調用seekForever方法========
尚未到終點
========66次調用seekForever方法========
尚未到終點
========67次調用seekForever方法========
尚未到終點
========68次調用seekForever方法========
尚未到終點
========69次調用seekForever方法========
尚未到終點
========70次調用seekForever方法========
尚未到終點
========71次調用seekForever方法========
尚未到終點
========72次調用seekForever方法========
尚未到終點
========73次調用seekForever方法========
尚未到終點
========74次調用seekForever方法========
尚未到終點
========75次調用seekForever方法========
尚未到終點
========76次調用seekForever方法========
尚未到終點
========77次調用seekForever方法========
尚未到終點
========78次調用seekForever方法========
尚未到終點
========79次調用seekForever方法========
尚未到終點
========80次調用seekForever方法========
尚未到終點
========81次調用seekForever方法========
尚未到終點
========82次調用seekForever方法========
尚未到終點
========83次調用seekForever方法========
尚未到終點
========84次調用seekForever方法========
尚未到終點
========85次調用seekForever方法========
尚未到終點
========86次調用seekForever方法========
尚未到終點
========87次調用seekForever方法========
尚未到終點
========88次調用seekForever方法========
尚未到終點
========89次調用seekForever方法========
尚未到終點
========90次調用seekForever方法========
尚未到終點
========91次調用seekForever方法========
📦📦📦📦📦📦📦📦📦
📦🐾           📦
📦🐾📦📦  📦📦   📦
📦🐾📦   📦    📦
📦🐾📦  📦 📦  📦
📦🐾🐾     📦  📦
📦📦🐾📦📦  📦📦📦
📦   🐾🐾🐾🐾🐾🐾📦
📦📦📦📦📦📦📦📦📦
========92次調用seekForever方法========
尚未到終點
========93次調用seekForever方法========
尚未到終點
========94次調用seekForever方法========
尚未到終點
========95次調用seekForever方法========
尚未到終點
========96次調用seekForever方法========
尚未到終點
========97次調用seekForever方法========
尚未到終點
========98次調用seekForever方法========
尚未到終點
========99次調用seekForever方法========
尚未到終點
========100次調用seekForever方法========
尚未到終點
========101次調用seekForever方法========
尚未到終點
========102次調用seekForever方法========
尚未到終點
========103次調用seekForever方法========
尚未到終點
========104次調用seekForever方法========
尚未到終點
========105次調用seekForever方法========
尚未到終點
========106次調用seekForever方法========
尚未到終點
========107次調用seekForever方法========
尚未到終點
========108次調用seekForever方法========
尚未到終點
========109次調用seekForever方法========
尚未到終點
========110次調用seekForever方法========
尚未到終點
========111次調用seekForever方法========
尚未到終點
========112次調用seekForever方法========
尚未到終點

相關題目其餘變形:

1.地下城遊戲(來源:力扣LeetCode)

  這個力扣的地下城遊戲問題是一個提高版,你們看了首先第一個意識就是能夠這麼去分析,其實這個就是動態規劃了,我目前尚未整理動態規劃的相關知識,算法的基礎合集估計之後會出,前提是我尚未被產品經理累死,哈哈哈。
  你們本身看看把,個人專欄也收錄了,連接給大家,本身去看,能夠練練手,地下城遊戲(困難難度)——萬能的遞歸與動態分析
資源耗用狀況
  哈哈,炫耀炫耀。


  其餘的變形我也不給了,十一了,明天就要出去浪了,懶得本身想了🙄🙄,哈哈哈,其實相關相似的題在力扣領釦都挺多的,你們能夠本身去看看,很好玩兒的。

官方題解

老鼠走迷宮(一)

解法

  老鼠的走法有上、左、下、右四個方向,在每前進一格以後就選一個方向前進,沒法前進時退回選擇下一個可前進方向,如此在陣列中依序測試四個方向,直到走到出口爲止,這是遞迴的基本題,請直接看程式應就能夠理解。

代碼——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("◇"); 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;
}

老鼠走迷宮(二)

解法

  求全部路徑看起來複雜但其實更簡單,只要在老鼠走至出口時顯示通過的路徑,而後退回上一格從新選擇下一個位置繼續遞迴就能夠了,比求出單一路徑還簡單,咱們的程式只要做一點修改就能夠了。

代碼——C語言

#include <stdio.h>
#include <stdlib.h>
void visit(int, int);
int maze[9][9] = { { 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}};
int startI = 1, startJ = 1;
// 入口
int endI = 7, endJ = 7;
// 出口
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");
	}
	visit(startI, startJ);
	return 0;
}
void visit(int i, int j) { 
	int m, n;
	maze[i][j] = 1;
	if(i == endI && j == endJ) { 
		printf("\n顯示路徑:\n");
		for (m = 0; m < 9; m++) { 
			for (n = 0; n < 9; n++)
			if(maze[m][n] == 2)
			printf("█"); else if(maze[m][n] == 1)
			printf("◇"); else
			printf(" ");
			printf("\n");
		}
	}
	if(maze[i][j+1] == 0) visit(i, j+1);
	if(maze[i+1][j] == 0) visit(i+1, j);
	if(maze[i][j-1] == 0) visit(i, j-1);
	if(maze[i-1][j] == 0) visit(i-1, j);
	maze[i][j] = 0;
}
相關文章
相關標籤/搜索