BfS

Author: AnfangRobkit

4.算法基础/week8/CatchCow.cpp

@@ -1,56 +1,99 @@
-/*
-//农夫知道一头牛的位置，想要抓住它。农夫和牛都位于数轴上，农夫起始位于点N(0<=N<=100000)，牛位于点K(0<=K<=100000)
-农夫有两种移动方式：
-1、从X移动到X-1或X+1，每次移动花费一分钟
-2、从X移动到2*X，每次移动花费一分钟
- 假设牛没有意识到农夫的行动，站在原地不动。农夫最少要花多少时间才能抓住牛？
-*/
-#include <iostream>
-#include <cstring>
-#include <queue>
+#include<iostream>
+#include<queue>
 using namespace std;
-int N, K;
-const int MAXN = 100000;
-int visited[MAXN + 10]; //判重标记，为true表示该点已经扩展过了
-struct Step
+
+const int board_size = 4;
+const int direction_num = 4;
+struct Piece
 {
-    int x;     //位置
-    int steps; //到达x需要的步数
-    Step(int xx, int ss) : x(xx), steps(ss) {}
+    int status;//状态值
+    int steps; //步数
+    Piece(int st, int step):status(st),steps(step){}
 };
-queue<Step> q; //队列，即open表
-int main()
+int direction[direction_num][2] = {
+    {-1,0}, {0,1},{1,0},{0,-1}
+};
+int pos[board_size *board_size]; //16种反转可能性
+bool marker[1<<(board_size*board_size)];
+
+bool inBoard(int x, int y)
 {
-    cin >> N >> K;
-    memset(visited, 0, sizeof(visited));
-    q.push(Step(N, 0)); //把起始位置放入Open表
-    while (!q.empty())
+    if(x>=0 && x<board_size && y>=0 && y<board_size)
+        return true;
+    else
+        return false;
+}
+void FlipInitialize()
+{
+    for (int i = 0; i < board_size; i++)
     {
-        Step s = q.front(); //拿出Open表中第一个元素
-        if (s.x == K)
-        { //找到目标
-            cout << s.steps << endl;
-            return 0;
-        }
-        else
+        for(int j = 0; j< board_size; j++)
         {
-            if (s.x - 1 >= 0 && !visited[s.x - 1])
+            // i*size+j  即为编号
+            int value = 1 << (i * board_size + j);
+            for(int k = 0; k<direction_num; k++)
             {
-                q.push(Step(s.x - 1, s.steps + 1));
-                visited[s.x - 1] = 1;
+                int next_x = i + direction[k][0];
+                int next_y = j + direction[k][1];
+                if(inBoard(next_x, next_y))
+                    value += 1 << (next_x *board_size + next_y);
             }
-            if (s.x + 1 <= MAXN && !visited[s.x + 1])
-            {
-                q.push(Step(s.x + 1, s.steps + 1));
-                visited[s.x + 1] = 1;
-            }
-            if (s.x * 2 <= MAXN && !visited[s.x * 2])
+            pos[i * board_size + j] = value;
+        }
+    }
+    
+}
+int BFS(int value)
+{
+    queue<Piece> q;
+    Piece s = Piece(value, 0);
+    q.push(s);
+    marker[s.status] = true;
+    while (!q.empty())
+    {
+        Piece cur = q.front();
+        q.pop();
+        //盘面全黑或者全白(2^16 -1)时结束，并返回步数
+        if(cur.status == 0 || cur.status == (1<<(board_size*board_size))-1)
+        {
+            return cur.steps;
+        }
+        //搜索16个位置
+        for(int i = 0; i< board_size*board_size; ++i)
+        {
+            //通过异或运算得到翻转后的状态
+            Piece next = Piece(cur.status ^ pos[i], cur.steps+1);
+            if(!marker[next.status])
             {
-                q.push(Step(s.x * 2, s.steps + !));
-                visited[s.x * 2] = 1;
+                q.push(next);
+                marker[next.status] = true;
             }
-            q.pop();
+
         }
     }
-    return 0;
+    return -1; //无法到达目标状态 返回-1
 }
+int main()
+{
+    FlipInitialize();
+    char str[5];
+    int value = 0;
+    for(int i=0; i<board_size; i++)
+    {
+         cin>>str;
+         for(int j=0; j<board_size; j++)
+         {
+             if(str[j]== 'w')
+                value += 1<<(i*board_size + j);
+                  // 加上 1<<(编号) 即可将此位置设置为1
+         }
+    }
+    int ans = BFS(value);
+    if(ans >= 0)
+        cout<<ans<<endl;
+    else
+    {
+        cout<<"Impossible"<<endl;
+    }
+    return 0;
+}

4.算法基础/week8/README.md

@@ -123,4 +123,23 @@ int main()
 DBFS算法是对BFS算法的一种扩展。
 
 - BFS算法从起始节点以广度优先的顺序不断扩展，知道遇到目的节点。
-- DBFS算法从两个节点以广度优先的顺序同时扩展，一个是从其实节点开始扩展，一个是从目的节点开始扩展，知道一个扩展队列中出现了另一个队列中已经扩展的节点，就相当于两个扩展的方向有了交点，那么可以认为我们找到了一条路径。
+- DBFS算法从两个节点以广度优先的顺序同时扩展，一个是从其实节点开始扩展，一个是从目的节点开始扩展，知道一个扩展队列中出现了另一个队列中已经扩展的节点，就相当于两个扩展的方向有了交点，那么可以认为我们找到了一条路径。
+
+DBFS算法相对于BFS算法来说，由于采用了双向扩展的方式，搜索树的宽度得到了明显的减少，所以在算法的时间复杂度和空间 复杂度上都有较大的优势。
+
+- 假设1个结点能扩展出n个结点，单向搜索要m层能找到答案，那么扩展出来的节点数目就是: (1-$n^m$)/(1-n) 
+-  双向广搜，同样是一共扩展m层，假定两边各扩展出m/2层，则总结点数目 2 * (1-$n^{m/2}$)/(1-n) 
+- 每次扩展结点总是选择结点比较少的那边进行扩展，并不是机械的两边交替.
+
+```cpp
+int expand(i) //其中i为队列的编号，0或1
+{
+ 	取队列qi的头结点H；
+ 	对H的每一个相邻节点adj：
+ 		1 如果adj已经在队列qi之中出现过，则抛弃adj；
+ 		2 如果adj在队列qi中未出现过，则:
+ 			1） 将adj放入队列qi；
+ 			2) 如果adj 曾在队列q1-i中出现过, 则：输出找到的路径
+} 
+```
+

4.算法基础/week8/assignment/flip_games.cpp

@@ -93,7 +93,7 @@ int main()
         cout<<ans<<endl;
     else
     {
-        cout<<"Impossible"<<endl;
+        cout<<"impossible"<<endl;
     }
     return 0;
 }

4.算法基础/week8/assignment/matze_problem.cpp

@@ -0,0 +1,79 @@
+#include <iostream>
+#include <queue>
+#include <string.h>
+using namespace std;
+
+bool is_wall[5][5];
+int a[5][5];
+int dx[4] = {0, 1, 0, -1};
+int dy[4] = {1, 0, -1, 0};
+
+struct Node
+{
+    int x;
+    int y;
+    int s;
+    short father[30];
+};
+
+bool Judge_Invalid(int x, int y)
+{
+    if(x<0 || x >=5 || y <0 || y>=5)
+        return true;
+    if(is_wall[x][y])
+        return true;
+    if(a[x][y] ==1)
+        return true;
+    return false;
+}
+Node Bfs()
+{
+    queue<Node> q;
+    Node cur, next;
+    cur.x = 0;
+    cur.y = 0;
+    cur.s = 0;
+    is_wall[cur.x][cur.y] = true;
+    q.push(cur);
+    while (!(q.empty()))
+    {
+        cur = q.front();
+        q.pop();
+        if(cur.x == 4 && cur.y ==4)
+            return cur;
+        int i, nx, ny;
+        for(i=0; i<4; i++)
+        {
+            nx = cur.x + dx[i];
+            ny = cur.y + dy[i];
+            if(Judge_Invalid(nx,ny))
+                continue;
+            next = cur;
+            next.x = nx;
+            next.y = ny;
+            next.s = cur.s + 1;
+            next.father[cur.s] = i;
+            q.push(next);
+        }
+    }
+    return cur;
+}
+int main()
+{
+     int i,j;
+    for(i=0;i<5;i++){   //读入迷宫
+        for(j=0;j<5;j++){
+            scanf("%d",&a[i][j]);
+        }
+    }
+    memset(is_wall,0,sizeof(is_wall));
+    Node ans = Bfs();
+    int x,y;
+    x = 0,y = 0;
+    for(i=0;i<=ans.s;i++){
+         printf("(%d, %d)\n",x,y);
+         x+=dx[ans.l[i]];
+         y+=dy[ans.l[i]];
+    }        
+    return 0;
+}