123

1.1.md

@@ -1,14 +0,0 @@
-综合运用线性表、栈和队列、图、查找和排序等数据结构知识，设计一个程
-序能够随机构造指定大小的迷宫，掌握和提高分析、设计、实现及测试程序
-的综合能力。
-要求
-设计一个程序随机生成指定大小的迷宫。一个迷宫是由 m*n 个方格组
-成的矩形区域，每个方格的四周可能存在墙，相邻的两个方格之间如果没有
-墙的阻隔则可以通行，否则无法通行。
-（1）指定迷宫的大小为 m 行 n 列，随机生成迷宫。
-（2）任意两个方格之间都存在通路。
-（3）在不重复通过的情况下，任意两个方格之间有且只有一条通路。
-（4）用文本文件保存迷宫，包括迷宫的大小和每一个被敲掉的墙。
-（5）尝试以图形窗口或文本方式显示迷宫。
-要求系统运行正常、功能完整；数据结构使用得当，算法有较高的效率；代
-码规范、可读性高，结构清晰；具备一定的健壮性、可靠性和可维护性。

1.2.md

@@ -1,5 +0,0 @@
-如果让所有存在通路的单元格组成一个集合，则构造迷宫可以看作是不断打破不同集合之间的墙，直至合并成一个集合的过程。迷宫的初始状态包含所
-有的墙，每个单元格属于一个独立的集合。随机敲掉两个集合之间的一个墙使两者相通，同时令两个集合合并成一个集合。不断重复，直到所有单元格
-都属于一个联通单元格的集合
-对于迷宫，我们一般是用一个二元的数组来存储迷宫中的单元，不同符号表示墙和可以通过的路径。我们的目的是在这个迷宫中找到一条从起点到终点的全部是可通过路径的单元组。
-从起点出发，向其四周探索，如果是可通过单元且没有访问过，则将其入栈并标记为已访问单元，并继续探索其它方向，如果其四周没有未访问的可通过单元，则说明该点为死点，我们就将其出栈。如果碰到终点，则停止探索，同时回溯栈中的点，把栈中的路径中的单元标记出来。

1.3.md

@@ -1,7 +0,0 @@
-（1）输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；
-输入行和列的长度，来设置迷宫的大小；
-（2）对迷宫，用栈来进行处理，栈是后进先出的线性数据结构，当每走一格时，就对上一格的坐标和向下一格要走的方向进行记录并规定每当遇到死路，即四个方向的“通路成立判断”都不成立时，从栈中取出栈顶元素，就这样到当前坐标值等于终点坐标值时，及循环停止时，栈中的所有元素自下而上就是对路径的全部描述。
-（3）读取输入的迷宫长度（m*n），对迷宫进行搜索路径，找到最短的路径
-（4）迷宫地图的大小和迷宫的入口位置
-（5）合并功能，能够使用户更方便的查看搜索结果，将多个数据合并成一个能够进行更高效的操作。
-（6）递归功能，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

README.md

@@ -1,16 +1,19 @@
 # 迷宫生成器
 
-成员1，成员2，成员3，成员4，成员5
+张桐桐，李玉璇，孟婷玉，周羽凡
 
-**摘要**：本项目针对什么问题，实现了哪些功能。为了有效地存储和处理何种数据，采用了何种数据结构。为了解决什么问题，采用了什么算法，算法效率如何。针对其他特定需求做了哪些工作。项目的整体效果如何，有何亮点和创新。
+**摘要**：设计一个程序随机生成指定大小的迷宫。一个迷宫是由 $M \times N$ 个方格组成的矩形区域，每个方格的四周可能存在墙，相邻的两个方格之间如果没有墙的阻隔则可以通行，否则无法通行。要求系统运行正常、功能完整；数据结构使用得当，算法有较高的效率；代码规范、可读性高，结构清晰；具备一定的健壮性、可靠性和可维护性。
 
 
 
 任务分工及完成情况。
+每个成员的工作量（百分比）：
 
+|  张桐桐  |   李玉璇  |  周羽凡   |孟婷玉|
+| ---- | ---- | ---- |----|
+|   30 |   30  |  20   |  20 |
 
 
-工作量占比。
 
 
 

src

@@ -0,0 +1,169 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+struct DisjointSet {
+    int* parent;
+    int* rank;
+    int n;
+};
+
+/* 初始化不相交集合*/
+struct DisjointSet* MakeSet(int n)
+{
+    struct DisjointSet* set = (struct DisjointSet*) malloc(sizeof(struct DisjointSet));
+    set->parent = (int*) malloc(n * sizeof(int));
+    set->rank = (int*) malloc(n * sizeof(int));
+
+    for (int i = 0; i < n; i++) {
+        set->parent[i] = i;
+        set->rank[i] = 0;
+    }
+
+    set->n = n;
+    return set;
+}
+
+/* 查找元素所在结合的代表元素*/
+int Find(struct DisjointSet* set, int x)
+{
+    if (set->parent[x] != x) {
+        set->parent[x] = Find(set, set->parent[x]);
+    }
+    return set->parent[x];
+}
+
+/* 合并两个集合*/
+void Union(struct DisjointSet* set, int x, int y)
+{
+    int root1 = Find(set, x), root2 = Find(set, y);
+    if (root1 != root2) {
+        if (set->rank[root1] > set->rank[root2]) {
+            set->parent[root2] = root1;
+        } else if (set->rank[root1] < set->rank[root2]) {
+            set->parent[root1] = root2;
+        } else {
+            set->parent[root2] = root1;
+            set->rank[root1] += 1;
+        }
+        set->n--;
+    }
+}
+
+/* 判断两个集合是否属于同一组*/
+int Connected(struct DisjointSet* set, int x, int y)
+{
+    return Find(set, x) == Find(set, y);
+}
+
+/* 定义Maze数据结构存储*/
+struct Maze {
+    int rows, cols;
+    int* top; //上边界
+    int* left; //左边界
+};
+
+/* 初始化迷宫结构*/
+struct Maze* InitMaze(int rows, int cols)
+{
+    struct Maze* maze = (struct Maze*) malloc(sizeof(struct Maze));
+    maze->rows = rows;
+    maze->cols = cols;
+    maze->top = (int*) malloc(rows * cols * sizeof(int));
+    maze->left = (int*) malloc(rows * cols * sizeof(int));
+
+    for (int i = 0; i < rows * cols; i++) {
+        maze->top[i] = i - cols >= 0 ? i - cols : -1;
+        maze->left[i] = i % cols > 0 ? i - 1 : -1;
+    }
+
+    return maze;
+}
+
+/* 生成迷宫*/
+struct Maze* GenerateMaze(int rows, int cols)
+{
+    struct Maze* maze = InitMaze(rows, cols);
+    struct DisjointSet* set = MakeSet(rows * cols);
+    srand(time(NULL));
+
+    while (set->n > 1) {
+        int wall = rand() % (rows * cols * 2) + 1;
+        int row, col;
+        if (wall <= rows * cols) { //竖直边界
+            row = (wall - 1) / cols;
+            col = (wall - 1) % cols;
+            if (maze->top[wall - 1] != -1) {
+                if (!Connected(set, wall - 1, maze->top[wall - 1])) {
+                    Union(set, wall - 1, maze->top[wall - 1]);
+                    maze->top[wall - 1] = -1;
+                }
+            }
+        } else { //水平边界
+            wall -= rows * cols;
+            row = (wall - 1) % rows;
+            col = (wall - 1) / rows;
+            if (maze->left[wall - 1] != -1) {
+                if (!Connected(set, wall - 1, maze->left[wall - 1])) {
+                    Union(set, wall - 1, maze->left[wall - 1]);
+                    maze->left[wall - 1] = -1;
+                }
+            }
+        }
+    }
+
+    free(set->parent);
+    free(set);
+    return maze;
+}
+
+/* 打印迷宫*/
+void PrintMaze(struct Maze* maze)
+{
+    int row, col; //打印竖直边界
+    for (row = 0; row < maze->rows; row++) {
+        for (col = 0; col < maze->cols; col++) {
+            printf("+");
+            if (row == 0 && maze->top[col] == -1) {
+                printf("   ");
+            } else if (row > 0 && maze->top[row * maze->cols + col] == -1) {
+                printf("   ");
+            } else {
+                printf("---");
+            }
+        }
+        printf("+\n");
+
+        /* 打印水平边界*/
+        for (col = 0; col < maze->cols; col++) {
+            if (col == 0 && maze->left[row * maze->cols] == -1) {
+                printf(" ");
+            } else if (col > 0 && maze->left[row * maze->cols + col] == -1) {
+                printf(" ");
+            } else {
+                printf("|");
+            }
+            printf("   ");
+        }
+        printf("|\n");
+    }
+
+    /* 打印最后一行的竖直边界*/
+    for (col = 0; col < maze->cols; col++) {
+        printf("+");
+        if (maze->top[(maze->rows - 1) * maze->cols + col] == -1)
+            printf("   ");
+        else
+            printf("---");
+    }
+    printf("+\n");
+}
+
+int main()
+{
+    int rows , cols;
+    scanf("%d%d",&rows,&cols);
+    struct Maze* maze = GenerateMaze(rows, cols);
+    PrintMaze(maze);
+    return 0;
+}