UVaOJ 705 - Slash Maze

最新推荐文章于 2023-12-06 19:53:24 发布

Ra_WinDing

最新推荐文章于 2023-12-06 19:53:24 发布

阅读量1.5k

点赞数

分类专栏： ICPC-report

本文链接：https://blog.csdn.net/Ra_WinDing/article/details/7724290

版权

ICPC-report 专栏收录该内容

106 篇文章 0 订阅

订阅专栏

——by A Code Rabbit

Description

输入一张迷宫图，全部由 '/'、'\' 组成。
这样，迷宫就变成一个斜线迷宫。

因为输入全为 '/' 、'\' ，因此，这个迷宫将由全部宽度为1的路径组成。
要求输出迷宫中有几个回环，即封闭的路径有几条，其中最长的有多长。

Types

Date Structure :: Graphs

Analysis

经典的斜线迷宫题。

可用 FloodFill 解决。

首先知道，没有封闭的路径，必然将通往图的外面。

所以只要从图的边界开始 FloodFill，把不满足条件的排除后。

再对每一个点去 FloodFill 即可求出所要的解。

而对于斜线的处理，有三种方法：

1. 九分法：将所有的格子都扩大成 9 * 9 的格子，例如

‘/’ 就会变成

然后只要用普通的 FloodFill 对每格上下左右四个方向的 DFS 就可以。

2. 四分法：将所有的格子扩大成 4 * 4 的格子，例如

‘/’ 就会变成

然后依然是对每个格子向八个方向 FloodFill ，但是要注意，在 2 * 2 格子中的某点向周围Flood 的时候，只能到达上下左右的 2 * 2格子。

反之如果 FloodFill 后依然在原先的 2 * 2格子，或者对角线方向的 2 * 2 格子的，将会是穿过了 '/' 的非法情况，需要排除掉。

3. 光线反射法：模拟一条光线在迷宫中照射，继续看图：

对于每个格子，光线可能从四个方向射进来。

在 FloodFill 的时候，判断光线来的方向，找到下一个 FloodFill 的格子即可。

三种方法，第一种较为简单，但是要将原图长宽各扩大三倍，得到一张原图九倍大的新图。

而第二种方法，只要将原图扩大四倍，但是要判断要FloodFill的格子是否可以FloodFill。

而第三种方法，较为复杂，对光线进来的四个方向都要判断反射出去的方向，可以用一个 enum 配合 const 数组来映射，好处就是不用扩大原图，时间复杂度相对前两种，常数较低。

Solution

1. 九分法

// UVaOJ 705
// Slash Maze
// by A Code Rabbit

#include <cstdio>

struct Change {
    int x;
    int y;
};

Change CHANGE[] = {
              {-1, 0},
    { 0, -1},          { 0, 1},
              { 1, 0},
};

const int LIMITS_W = 1000;
const int LIMITS_H = 1000;

int num_case = 0;

char maze[LIMITS_H][LIMITS_W];
int w, h;
int w_maze, h_maze;

void EnlargeAndSave(int x, int y, char ch);

int FloodFill(int x, int y);

int main() {
    while (scanf("%d%d", &w, &h)) {
        getchar();
        // Exit.
        if (!w && !h) {
            break;
        }
        // Inputs.
        for (int i = 0; i < h; ++i) {
            for (int j = 0; j < w; ++j) {
                EnlargeAndSave(i, j, getchar());
            }
            getchar();
        }
        w_maze = w * 3;
        h_maze = h * 3;
        // DFS: Remove grids of the maze without cycles.
        for (int i = 0; i < h_maze; ++i) {
            FloodFill(i, 0);
            FloodFill(i, w_maze - 1);
        }
        for (int i = 0; i < w_maze; ++i) {
            FloodFill(0, i);
            FloodFill(h_maze - 1, i);
        }
        // DFS: Search and compete the maze with cycles.
        int max = 0;
        int sum = 0;
        for (int i = 0; i < h_maze; ++i) {
            for (int j = 0; j < w_maze; ++j) {
                int result = FloodFill(i, j) / 3;
                if (result) {
                    max = result > max ? result : max;
                    ++sum;
                }
            }
        }
        // Outputs.
        printf("Maze #%d:\n", ++num_case);
        if (sum) {
            printf("%d Cycles; the longest has length %d.\n", sum, max);
        } else {
            printf("There are no cycles.\n");
        }
        printf("\n");
    }
    
    return 0;
}

void EnlargeAndSave(int x, int y, char ch) {
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            maze[x * 3 + i][y * 3 + j] = ' ';
        }
    }
    if (ch == '/') {
        maze[x * 3][y * 3 + 2] = '#';
        maze[x * 3 + 1][y * 3 + 1] = '#';
        maze[x * 3 + 2][y * 3] = '#';
    } else {
        maze[x * 3][y * 3] = '#';
        maze[x * 3 + 1][y * 3 + 1] = '#';
        maze[x * 3 + 2][y * 3 + 2] = '#';
    }
}

int FloodFill(int x, int y) {
    // Exit.
    if (x < 0 || x >= h_maze
     || y < 0 || y >= w_maze) {
        return 0;
    }
    if (maze[x][y] != ' ') {
        return 0;
    }
    // Continue.
    maze[x][y] = '#';
    int sum = 1;
    for (int i = 0; i < 4; ++i) {
        sum += FloodFill(x + CHANGE[i].x, y + CHANGE[i].y);
    }
    return sum;
}

2. 四分法

// UVaOJ 705
// Slash Maze
// by A Code Rabbit

#include <cstdio>

struct Change {
    int x;
    int y;
};

Change STRAIGHT_CHANGE[] = {
              {-1, 0},
    { 0, -1},          { 0, 1},
              { 1, 0},
};

Change SLASH_CHANGE[] = {
    {-1, -1},          {-1, 1},
    
    { 1, -1},          { 1, 1},
};

const int LIMITS_W = 500;
const int LIMITS_H = 500;

int num_case = 0;

char maze[LIMITS_H][LIMITS_W];
int w, h;
int w_maze, h_maze;

void EnlargeAndSave(int x, int y, char ch);

bool canArrive(int x, int y, Change change);
int FloodFill(int x, int y);

int main() {
    while (scanf("%d%d", &w, &h)) {
        getchar();
        // Exit.
        if (!w && !h) {
            break;
        }
        // Inputs.
        for (int i = 0; i < h; ++i) {
            for (int j = 0; j < w; ++j) {
                EnlargeAndSave(i, j, getchar());
            }
            getchar();
        }
        w_maze = w * 2;
        h_maze = h * 2;
        // DFS: Remove grids of the maze without cycles.
        for (int i = 0; i < h_maze; ++i) {
            FloodFill(i, 0);
            FloodFill(i, w_maze - 1);
        }
        for (int i = 0; i < w_maze; ++i) {
            FloodFill(0, i);
            FloodFill(h_maze - 1, i);
        }
        // DFS: Search and compete the maze with cycles.
        int max = 0;
        int sum = 0;
        for (int i = 0; i < h_maze; ++i) {
            for (int j = 0; j < w_maze; ++j) {
                int result = FloodFill(i, j);
                if (result) {
                    max = result > max ? result : max;
                    ++sum;
                }
            }
        }
        // Outputs.
        printf("Maze #%d:\n", ++num_case);
        if (sum) {
            printf("%d Cycles; the longest has length %d.\n", sum, max);
        } else {
            printf("There are no cycles.\n");
        }
        printf("\n");
    }
    
    return 0;
}

void EnlargeAndSave(int x, int y, char ch) {
    maze[x * 2][y * 2] = ch == '/' ? ' ' : '#';
    maze[x * 2][y * 2 + 1] = ch == '/' ? '#' : ' ';
    maze[x * 2 + 1][y * 2] = ch == '/' ? '#' : ' ';
    maze[x * 2 + 1][y * 2 + 1] = ch == '/' ? ' ' : '#';
}

bool canArrive(int x, int y, Change change) {
    int x_after_change = x % 2 + change.x;
    int y_after_change = y % 2 + change.y;
    if (0 <= x_after_change && x_after_change < 2
     && 0 <= y_after_change && y_after_change < 2) {
        return false;
    } else
    if ((x_after_change < 0 || x_after_change >= 2)
     && (y_after_change < 0 || y_after_change >= 2)) {
        return false;
    } else {
        return true;
    }
    printf("\n");
}

int FloodFill(int x, int y) {
    // Exit.
    if (x < 0 || x >= h_maze
     || y < 0 || y >= w_maze) {
        return 0;
    }
    if (maze[x][y] != ' ') {
        return 0;
    }
    // Continue.
    maze[x][y] = '.';
    int sum = 1;
    for (int i = 0; i < 4; ++i) {
        sum += FloodFill(x + STRAIGHT_CHANGE[i].x, y + STRAIGHT_CHANGE[i].y);
    }
    for (int i = 0; i < 4; ++i) {
        if (canArrive(x, y, SLASH_CHANGE[i])) {
            sum += FloodFill(x + SLASH_CHANGE[i].x, y + SLASH_CHANGE[i].y);
        }
    }

    return sum;
}

3. 光线反射法

// UVaOJ 705
// Slash Maze
// by A Code Rabbit

#include <cstdio>
#include <cstring>


enum Direction {
    UP = 0,
    DOWN = 1,
    LEFT = 2,
    RIGHT = 3,
};

struct Change {
    int x;
    int y;
};

const Direction DIRECTION[] = {
    UP,
    DOWN,
    LEFT,
    RIGHT,
};
// Form four directions what are UP, DOWN, LEFT, RIGHT.
const Change CHANGE[] = {
    {-1,  0},
    { 1,  0},
    { 0, -1},
    { 0,  1},
};

// Form four directions what are UP, DOWN, LEFT, RIGHT.
const Direction REFLEX_SLASH[] = {
    LEFT,
    RIGHT,
    UP,
    DOWN,
};
const Direction REFLEX_BACKSLASH[] = {
    RIGHT,
    LEFT,
    DOWN,
    UP, 
};

const int LIMITS_W = 100;
const int LIMITS_H = 100;

int num_case = 0;

char maze[LIMITS_W][LIMITS_H];
int w, h;

bool is_visited[LIMITS_W][LIMITS_H][4];

Direction Opposite(Direction direction);
int FloodFill(int x, int y, Direction direction);

int main() {
    while (scanf("%d%d", &w, &h)) {
        getchar();
        // Exit.
        if (!w && !h) {
            break;
        }
        // Inputs.
        for (int i = 0; i < h; ++i) {
            gets(maze[i]);
        }
        // DFS: Remove grids of the maze without cycles.
        memset(is_visited, false, sizeof(is_visited));
        for (int i = 0; i < h; ++i) {
            FloodFill(i, 0, LEFT);
            FloodFill(i, w - 1, RIGHT);
        }
        for (int i = 0; i < w; ++i) {
            FloodFill(0, i, UP);
            FloodFill(h - 1, i, DOWN);
        }
        //Show();
        // DFS: Search and compete the maze with cycles.
        int max = 0;
        int sum = 0;
        for (int i = 0; i < h; ++i) {
            for (int j = 0; j < w; ++j) {
                for (int k = 0; k < 4; k++) {
                    int result = FloodFill(i, j, DIRECTION[k]);
                    if (result) {
                        max = result > max ? result : max;
                        ++sum;
                    }
                }
            }
        }
        // Outputs.
        //Show();
        printf("Maze #%d:\n", ++num_case);
        if (sum) {
            printf("%d Cycles; the longest has length %d.\n", sum, max);
        } else {
            printf("There are no cycles.\n");
        }
        printf("\n");
    }


    return 0;
}

Direction Opposite(Direction direction) {
    if (direction == LEFT) {
        return RIGHT;
    } else
    if (direction == RIGHT) {
        return LEFT;
    } else
    if (direction == UP) {
        return DOWN;
    } else
    if (direction == DOWN) {
        return UP;
    }
}

int FloodFill(int x, int y, Direction direction) {
    // Exit.
    if (x < 0 || x >= h
     || y < 0 || y >= w) {
        return 0;
    }
    if (is_visited[x][y][direction]) {
        return 0;
    }
    is_visited[x][y][direction] = true;
    // Continue.
    Direction direction_leave;
    if (maze[x][y] == '/') {
        direction_leave = REFLEX_SLASH[direction];
    } else {
        direction_leave = REFLEX_BACKSLASH[direction]; 
    }
    is_visited[x][y][direction_leave] = true;
    return 1 + FloodFill(x + CHANGE[direction_leave].x,
                         y + CHANGE[direction_leave].y,
                         Opposite(direction_leave));
}

下载PDF

参考资料：wjjayo博客 crystal_yi博客 Penseur博客