Mirror Maze (2024牛客多校1 I)

已于 2024-07-21 18:01:07 修改
阅读量581 收藏 11
点赞数 25
文章标签： 图论 深度优先 算法
于 2024-07-21 18:00:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jushdi/article/details/140591375
版权 
进入博客阅读体验更佳：Mirror Maze (2024牛客多校1 I) | 付诺の小站 (funuo0728.github.io)

Mirror Maze

题目大意

给定一个n \times m(1 \le n,m \le 1000)大小的矩阵，每个格子上都有一面镜子，镜子共有以下4种类型：

  • "-" 反射来自上方和下方的光，来自左边和右边的光将平行穿过；

  • "|" 反射来自左边和右边的光，来自上方和下方的光将平行穿过；

  • "\setminus" 将来自上、下、左、右方向的光反射成朝向分别为右、左、下、上的光；

  • "/" 将来自上、下、左、右方向的光反射成朝向分别为左、右、上、下的光；

共有q(1 \le q \le 10^5)次询问，每次给出光源的位置和方向，问每个光源的光最终会反射多少枚不同的镜子。

解题思路

由于n \times m的大小的10^6，算上每格所包含的4种不同状态数量级依然为10^6，那么总共是4 \times 10 ^ 6个点，可以想到遍历预处理。

继续思考每个每个点之间的关系，发现每个点只能唯一地转移到下一个点，所以光的运动轨迹要么是个环，要么是一条链，环与链都是各自独立的，并且链的两端一定对应矩形的边界。换句话说，光一定是从外界进入到矩阵，再从矩阵中被反射出去，或者会一直在矩阵中循环。

厘清这一点就可以想到只需要对最外围的一圈做一次bfs或dfs遍历就可以预处理出所有的链，等询问碰到环的情况再去处理环。奈何笔者笨了点，并没有想到这样写，补题时的想法是反正每个点都要被遍历，那就在询问的时候进行遍历也是一样的。结果这样写还得把当前点所处的一整条链遍历处理才行，也就是说，笔者的做法是对于处在一条链上的点，首先按照反方向找到链的起点，再反向遍历到终点才行。

那么如何统计环和链所反射的镜子个数呢，只需要用一个set去存储所遍历过的镜子即可，注意到对于斜放的镜子，两面都有可能会被光经过，所以笔者采用set避免重复计算。

剩下的就只是对于模拟光在镜子上的反射过程了，比较繁琐但思路清晰，不再赘述。

参考代码

#include <bits/stdc++.h>
#define maxn 1010
// #define int long long
using namespace std;
const double eps = 1e-8;
struct node{
    int x, y, s;
};
int n, m, res[maxn][maxn][5], wk[5][2] = {{0, 0}, {-1, 0}, {1, 0}, {0, -1}, {0, 1}};
bool vis[maxn][maxn][5];
char g[maxn][maxn];
​
int get(int x, int y, string s) {
    int cur = (x - 1) * m * 4 + (y - 1) * 4;
    if(s == "above")  cur += 1;
    else if(s == "below")  cur += 2;
    else if(s == "left")  cur += 3;
    else if(s == "right")  cur += 4;
    return cur;
}
​
int get(int x, int y, int s) {
    int cur = (x - 1) * m * 4 + (y - 1) * 4 + s;
    return cur;
}
​
node irrget(int x) {
    node tmp = {0, 0, 0};
    tmp.s = (x - 1) % 4 + 1;
    tmp.y = ((x - 1) % (4 * m) + 1 + 3) / 4;
    tmp.x = (x + 4 * m - 1) / (4 * m);
    return tmp;
}
​
int getdir(int x, char s) {
    int res;
    if(x == 1) {
        if(s == '-')  res = 2;
        else if(s == '|')  res = 1;
        else if(s == '/')  res = 4;
        else if(s == '\\') res = 3;
    }
    else if(x == 2) {
        if(s == '-')  res = 1;
        else if(s == '|')  res = 2;
        else if(s == '/')  res = 3;
        else if(s == '\\')  res = 4;
    }
    else if(x == 3) {
        if(s == '-')  res = 3;
        else if(s == '|')  res = 4;
        else if(s == '/')  res = 2;
        else if(s == '\\')  res = 1;
    }
    else if(x == 4) {
        if(s == '-')  res = 4;
        else if(s == '|')  res = 3;
        else if(s == '/')  res = 1;
        else if(s == '\\')  res = 2;
    }
    return res;
}
​
int htt(node tt) {
    int res;
    if(g[tt.x][tt.y] == '-') {
        if(tt.s == 1)  res = -1;
        else if(tt.s == 2)  res = -1;
        else if(tt.s == 3)  tt.s = 4, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 4)  tt.s = 3, res = get(tt.x, tt.y, tt.s);
    }
    else if(g[tt.x][tt.y] == '|') {
        if(tt.s == 1)  tt.s = 2, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 2)  tt.s = 1, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 3)  res = -1;
        else if(tt.s == 4)  res = -1;
    }
    else if(g[tt.x][tt.y] == '\\') {
        if(tt.s == 1)  tt.s = 4, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 2)  tt.s = 3, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 3)  tt.s = 2, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 4)  tt.s = 1, res = get(tt.x, tt.y, tt.s);
    }
    else if(g[tt.x][tt.y] == '/') {
        if(tt.s == 1)  tt.s = 3, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 2)  tt.s = 4, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 3)  tt.s = 1, res = get(tt.x, tt.y, tt.s);
        else if(tt.s == 4)  tt.s = 2, res = get(tt.x, tt.y, tt.s);
    }
    return res;
}
​
int bfs(int x) {
    if(x == 62) {
        int ppp = 1;
    }
    node tt = irrget(x);
    if(res[tt.x][tt.y][tt.s] != -1)  return res[tt.x][tt.y][tt.s];
​
    vector<int> tmp;  tmp.push_back(x);
    queue<int> q;  q.push(x);
​
    vis[tt.x][tt.y][tt.s] = true;
    bool flag = false;
    while(q.size()) {
        node t = irrget(q.front());  q.pop();
        int tx = t.x + wk[t.s][0], ty = t.y + wk[t.s][1];
        if(tx < 1 || tx > n || ty < 1 || ty > m)  continue;
        int ts = getdir(t.s, g[tx][ty]);
        if(vis[tx][ty][ts]) {
            int xq = get(tx, ty, ts);
            tmp.push_back(xq);
            flag = true;  continue;
        }
        int xq = get(tx, ty, ts);
        tmp.push_back(xq);  q.push(xq);
        vis[tx][ty][ts] = true;
    }
​
​
    if(flag) {
        set<pair<int, int>> cnt;
        int k = tmp.size(), lst = -1;
        for (int i = k - 1; i >= 0; --i) {
            node t = irrget(tmp[i]), lt;
            // cout << t.x << ' ' << t.y << ' ' << t.s << '\n';
            if(i != k - 1)  lt = irrget(tmp[i + 1]);
            if(lst == -1)  lst = t.s;
            else if(t.s != lst) {
                lst = t.s;
                cnt.insert(make_pair(lt.x, lt.y));
            }
        }
        for (auto u : tmp) {
            node t = irrget(u);
            res[t.x][t.y][t.s] = (int)cnt.size();
        }
    }
    else {
        for (auto u : tmp) {
            node xq = irrget(u);
            vis[xq.x][xq.y][xq.s] = false;
        }
        tmp.clear();
        int y = htt(tt);
​
        int start;
        if(y != -1) {
            q.push(y);
            while(q.size()) {
                node t = irrget(q.front());  
                int tx = t.x + wk[t.s][0], ty = t.y + wk[t.s][1];
                if(tx < 1 || tx > n || ty < 1 || ty > m) {
                    start = q.front();  q.pop();
                    continue;
                }
                q.pop();
                int ts = getdir(t.s, g[tx][ty]);
                int xq = get(tx, ty, ts);
                q.push(xq);
            }
        }
​
        if(y == -1)  start = x;
        else  start = htt(irrget(start));
        q.push(start);  tmp.push_back(start);
        while(q.size()) {
            node t = irrget(q.front());  q.pop();
            int tx = t.x + wk[t.s][0], ty = t.y + wk[t.s][1];
            if(tx < 1 || tx > n || ty < 1 || ty > m)  continue;
            int ts = getdir(t.s, g[tx][ty]);
            int xq = get(tx, ty, ts);
            tmp.push_back(xq);  q.push(xq);
        }
​
        set<pair<int, int>> cnt;
        int k = tmp.size(), lst = -1;
        for (int i = k - 1; i >= 0; --i) {
            node t = irrget(tmp[i]), lt;
            if(i != k - 1)  lt = irrget(tmp[i + 1]);
            if(lst == -1)  lst = t.s;
            else if(t.s != lst) {
                lst = t.s;
                cnt.insert(make_pair(lt.x, lt.y));
            }
            res[t.x][t.y][t.s] = cnt.size();
        }
    }
​
    // if(vis[4][4][2]) {
    //     cout << "x: " << x << " tt.x: " << tt.x << " tt.y: " << tt.y << " tt.s: " << tt.s << '\n';
    //     exit(0);
    // }
​
    return res[tt.x][tt.y][tt.s];
}
​
void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            cin >> g[i][j];
            for (int k = 1; k <= 4; ++k)  res[i][j][k] = -1;
        }
    }
    int q;  cin >> q;
    while(q--) {
        int x, y;
        string s; 
        cin >> x >> y >> s;
        cout << bfs(get(x, y, s)) << '\n';
    }
}
​
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);  cout.tie(0);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
}
jushdi
关注
题解|2024暑期牛客多校01
CCLMSY‘s Blog
07-16 1582
题解|2024暑期牛客多校01
2024牛客暑期多校训练营1 I Mirror Maze
2301_81488029的博客
07-18 610
来源：牛客网。
【牛客】2024暑期牛客多校1 补题记录
Texcavator的博客
07-18 1204
等空了看看能不能补J。
2024牛客暑期多校训练营1
lujw17的博客
07-18 918
文章目录A. A Bit CommonProblemSoultionCodeB. A Bit More CommonProblemSoultionCodeC. Sum of Suffix SumsProblemSoultionCodeH. World FinalsProblemSoultionCodeI. Mirror MazeProblemSoultionCode A. A Bit Common Problem 给定两个整数 nnn 和 mmm，问有多少个长度为 nnn 的序列 {A}i=1n(Ai&lt
2024牛客暑期多校1（新手题）
2301_79902706的博客
07-18 1093
有两场World Finals同时举办，每场都有若干出线队伍，两场出线名单可能有重复的队伍，而一个队伍只能选择其中的一场参加，然后每场比赛的每支队伍都有一个预测成绩（过题数+ 罚时）lzr010506在两场World Finals 都出线了，他想知道如果所有队伍的最终成绩就是预测成绩，并且可以任意分配两场都出线了队伍的比赛场次的选择，他们队最高可能的排名是多少（1 ≤ number of teams ≤ 10^5）公式：C(k,n)×2^((m-1)(n-k))×(2^k-1)^(m-1)
2024牛客暑期多校训练营1 I-Mirror Maze
osakooo的博客
07-17 548
另外用 v[N][N] 记录是否发生反射，注意对于 | 和 - 这两种镜子，分别从上、下和左、右的光不反射，此时不能标记v[N][N]为1。注意每次DFS后将D和v值为0。对于每面镜子对应着上、下、左、右射来的广四种状态，使用 D[N][N][5] 记录每种状态是否经过，若同一种状态被访问两次，则存在回路，跳出DFS。
I-Mirror Maze（牛客暑期1）
m0_74310050的博客
07-24 360
如果光源在环内，也就是与环外不同的是，光源走的路上的每个点与光源的答案是一样的，因为他们一定会循环，光是可逆的。先在有q个光源，光源在（u，v）坐标，光源沿着dir（above上，below下，left左，right右）方向发射，发射的光将反射不同镜子的数量。1.“-”，来自上方或下方的光将反射回来，来自左边或右边的光将分别继续向前移动而不会被反射。3.“/”来自左，右，上，下的光将分别反射到上，下，左，右。4.“\”来自左，右，上，下的光将分别反射到下，上，右，左。
2024牛客多校1
weixin_73662789的博客
07-19 331
遍历四边上的所有点，作为光线的起点，向里面射入，dfs模拟光线的路线，记录经过的反射光线的点，直到射出，更新经过的所有点的a[i][j][p]的值，p为在该位置光线射来的方向。对于所有链中均没有遍历到的某个点的射向方向，则该光路必然形成环，对所有环dfs模拟光线的路线，记录经过的反射光线的点，直到回到环的起点，更新经过的所有点的a[i][j][p]的值。对于每一行（每个二进制位），满足至少一个数在该位的值为0的组合个数即为全部可能的组合个数-k个数该位全为1的情况，即为。对于每个询问，O（1）回答。
2024牛客暑期多校训练营1 I.Mirror Maze（题解）
Fun_Total的博客
07-17 838
给一个n×m的二维char数组，由4种镜子组成，‘\’, ‘/’, ‘-’, ‘|’，镜面反射规则就是根据光线的方向和镜面的角度符合直觉的反射，然后有多组询问q≤106，每次给定起始位置和光线方向，求该光会经过多少面不同的镜子的反射。
Maze-Solving-Robot-master_Nes1200in1_1200in1_Enjoy_
09-28
1. 迷宫解决机器人（Maze-Solving-Robot-master）： 迷宫解决机器人是机器人技术与人工智能的结合，它利用算法来寻找并解决复杂迷宫的问题。这种机器人通常装备有传感器，如超声波、激光雷达或摄像头，来感知环境并...
random-maze.zip_FPGA 迷宫_PS2 VGA INTERFACE _fpga游戏_maze_random
09-20
在这个项目中，“random-maze.zip”是一个包含FPGA迷宫游戏的压缩包，其重点是利用FPGA技术、PS2键盘接口以及VGA显示接口来创建一个互动游戏。 首先，我们要理解FPGA迷宫游戏的基本概念。FPGA迷宫游戏是通过编程在...
Maze(1).dep
12-09
Maze(1).dep
题解 | Maze-2019牛客暑期多校训练营第二场E题
lastbye的博客
08-15 223
题目来源于牛客竞赛：https://ac.nowcoder.com/acm/contest/discuss 题目描述： Given a maze with N rows and M columns, where bij represents the cell on the i-row, j-th column. If bij=“1” , it’s a wall and can’t not be p...
图论(dfs系列) 9/27
2301_78191305的博客
09-27 846
2.将所有的连通块找出来之后，然后枚举所有的海洋块。判断海洋块的周围有没有两个连通块(最多只能有两个连通块)。在以往的dfs搜索中，都是往四个方向去dfs；但是在这一道题中，四个方向是不行的；如果第i次是从左往右过来的，那么i+1次，就不能从右往左再过。给定一个二维数组grid,如果二维数组中存在一个环，处于环上的值都是相同的。如果不存在就返回false；1.首先找到所有的岛屿(连通块)，将他们存储到map表中。如果上一次不是从左边来的，那我们就可以往左走；如果上一次不是从右边来的，那我们就可以往右走；
深度优先搜索（DFS）解题思路解析：如何通过图论计算除法求值
最新发布
qq_22841387的博客
09-30 769
通过构建图并利用 DFS 或 BFS 来解决除法求值问题，能够高效处理多个查询。在解决此类问题时，图论的表示和搜索算法是非常直观且有效的选择。
图论(bfs系列)9/30
2301_78191305的博客
09-30 636
1.首先我们将所有值为1的点都加入到队列中，然后将值为0的点的值都改为-1；（为什么是step-1呢，因为在最后一次查找的时候，已经无法再向外层扩展了，但还是++，所以最后返回的时候应该再减去1）1.首先，这是一个单源点的bfs搜索题，for循环不断遍历每一次搜索能到达的点，然后把这些点加入queue队列中。多源点问题：1.首先将所有的值为1的点都加入队列中，然后将值为0的点赋值为不能达到的值。我们可以计算1到最近的0的距离的最大值。2.然后判断矩阵的规格，如果是1*1的矩阵，直接返回1；
匈牙利算法模板
qq_42643660的博客
09-30 176
匈牙利算法
Maze函数 python
09-24
if x < width - 1 and maze[x + 1][y] == ' ': fill_path(x + 1, y) if y < height - 1 and maze[x][y + 1] == ' ': fill_path(x, y + 1) start_x, start_y = random.randint(0, width - 1), random.randint(0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值