圖來自啊哈算法

這裏描述的問題就是如何從1,1走到4,3

這裏有兩個解決方案,一個是用深度優先算法

　　初始化地圖,和標記點

        int[,] ditu = new int[5, 4]{
                {0,0,1,0},
                {0,0,0,0},
                {0,0,1,0},
                {0,1,0,0},
                {0,0,0,1}
            };
        int[,] book_1 = new int[5, 4];

　　定義每次走的方向

        int
 
[,] fanxiang = new int[4, 2] {
            {0,1},//右邊
            {1,0},//下邊
            {0,-1},//左邊
            {-1,0}//上邊
        };

        private void dyzdlj(int x, int y, int step)
        {
            if (x == 3 && y == 2)
            {
                if (step < min)
                {
                    min 
 
= step;
                }
                Console.WriteLine("我找到了一種走的方法了,一共走了{0}步", step);
                return;
            }
            for (int i = 0; i < 4; i++)
            {
                //走
                int tx = x + fanxiang[i, 0];
                int ty = y + fanxiang[i, 1];
                
 
//判斷是否越界
                if (tx < 0 || ty < 0 || tx > 4 || ty > 3)
                {
                    continue;
                }
                if (book_1[tx, ty] == 0 && ditu[tx, ty] == 0)
                {
                    book_1[tx, ty] = 1;
                    dyzdlj(tx, ty, step + 1);
                    book_1[tx, ty] = 0;
                }
            }
        }

　　2.廣度搜索,所謂的廣度搜索呢,就是每次把能走的全部走光

　　定義基本的結構,用來保存數據

    public struct node
    {
        public int x;//x坐標
        public int y;//y坐標
        public int s;//步數
    }

　　具體實現

        private void gdyxsf()
        {
            node[] nn = new node[20];
            int head = 0, tail = 0;
            //設置起點
            nn[head].x = 0;
            nn[head].y = 0;
            nn[head].s = 0;
            book_1[0, 0] = 1;
            tail++;
            int flag = 0;
            while (head<tail)
            {
                
                for (int i = 0; i < 4; i++)
                {
                    int tx =nn[head].x+fanxiang[i, 0];
                    int ty = nn[head].y + fanxiang[i, 1];
                    if (tx<0||ty<0||tx>4||ty>3)
                    {
                        continue;
                    }
                    //判斷地圖是否被走過
                    if (ditu[tx,ty]==0&&book_1[tx,ty]==0)
                    {
                        book_1[tx, ty] = 1;
                        nn[tail].x = tx;
                        nn[tail].y = ty;
                        nn[tail].s = nn[head].s + 1;
                        tail++;
                    }
                    if (book_1[3,2]==1)
                    {
                        flag = 1;
                        break;
                    }
                }
                if (flag==1)
                {
                    Console.WriteLine("我已經到了這個地方了,我一共走了{0}步", nn[tail - 1].s);
                    break;
                }
                head++;
            }
        }

　　執行結果

深度優先和廣度優先的基礎應用