2023-07-18力扣今日二题-太难了吧

链接：

LCP 75. 传送卷轴

题意：

给一个正方形迷宫，主角是A，每次可以上下左右走一格子，有四种类型的格子：墙、初始位置、魔法水晶、空地

另一个人B，可以传送一次A，只能在空地传送（墙、初始位置、魔法水晶位置不能传送）

传送会将A传送到水平或者竖直的镜像位置，且目标不得为墙壁（如果两种镜像位置都是墙则不能传送）

求传送后，A到终点的最小距离，如果无法到达，返回-1

两个人都聪明绝顶

传送门:

两个普通的合法检查函数，脑子晕了没去简化，还用了两种坐标格式

两个镜像位置获取函数

一个BFS来记录每个格子到终点的距离，只要是方便计算传送后的距离,类似洪水填充寻路（MC水桶）

一个遍历获取传送后的距离，通过BFS得出的距离和两个翻转函数，存储在Mirror二维容器

先来一个优先队列排序用结构体

计算答案的函数

负责会传答案和初始化地图的工具人函数

碎碎念：

昨天摇到的困难题，昨晚在床上辗转反侧终于有了一点头猪，写完每日一题冲了一下，也就亿点点难

在这里插入图片描述

最终还是去看了一下大佬代码，又是打卡题上的老pong右，优先队列哇，修修补补好歹是过了，就是有点惨不忍睹
在这里插入图片描述

解：

这边来进入正题，先来看一个题目给的条件，如果无法到达，返回 -1，同时B的目标是阻止A到达终点以，如果存在一张地图A不通过传送无法到达终点，那么B就不会传送A，BUT还有一条条件：如果无法阻止，则尽可能增加 A传送后到达终点的距离。那么即使传送完剩下的距离小于传送前剩下的距离，B也会传送，我就是这里又WA了两次，比如"S....T..."，结果是2（其他格子都是墙）

代码很长，边看边聊：

两个普通的合法检查函数，脑子晕了没去简化，还用了两种坐标格式

bool check(const int& n,const int& m,const int& lg)//坐标合法检查 
{
    if(n<0||m<0) return false;
    if(n>=lg||m>=lg) return false;
    return true;
}
bool check(const pair<int,int>& pa,const int& lg)//坐标合法检查 
{
    const int n=pa.first,m=pa.second;
    if(n<0||m<0) return false;
    if(n>=lg||m>=lg) return false;
    return true;
}

两个镜像位置获取函数

inline pair<int,int> colMirror(const int& n,const int& m,const int& lg)//左右镜像-列镜像 
{
    return {n,lg-m-1};
}
inline pair<int,int> rowMirror(const int& n,const int& m,const int& lg)//上下镜像-行镜像 
{
    return {lg-n-1,m};
}

一个BFS来记录每个格子到终点的距离，只要是方便计算传送后的距离,类似洪水填充寻路（MC水桶）

void BFS_Distance(vector<vector<int>>& mp,const pair<int,int>& point,const int& lg)//类似洪水填充 
{
    vector<pair<int,int>>now{point};//当前坐标 
    while(true)
    {
        vector<pair<int,int>>next;//下一轮坐标 
        for(auto pa:now)
        {
            int nowx=pa.first,nowy=pa.second,nowval=mp[nowx][nowy];
            if(check(nowx-1,nowy,lg) && mp[nowx-1][nowy]==INT_MAX)//空地-初始位置
            {
                mp[nowx-1][nowy]=nowval+1;//更新距离
                next.push_back(pair<int,int>{nowx-1,nowy});
            }
            if(check(nowx+1,nowy,lg) && mp[nowx+1][nowy]==INT_MAX)//空地-初始位置
            {
                mp[nowx+1][nowy]=nowval+1;//更新距离
                next.push_back(pair<int,int>{nowx+1,nowy});
            }
            if(check(nowx,nowy-1,lg) && mp[nowx][nowy-1]==INT_MAX)//空地-初始位置
            {
                mp[nowx][nowy-1]=nowval+1;//更新距离
                next.push_back(pair<int,int>{nowx,nowy-1});
            }
            if(check(nowx,nowy+1,lg) && mp[nowx][nowy+1]==INT_MAX)//空地-初始位置
            {
                mp[nowx][nowy+1]=nowval+1;//更新距离
                next.push_back(pair<int,int>{nowx,nowy+1});
            }
        }
        now=next;
        if(now.empty()) break;
    }
}

一个遍历获取传送后的距离，通过BFS得出的距离和两个翻转函数，存储在Mirror二维容器

void BL_Mirror(vector<vector<int>>& Mirror,vector<vector<int>>& mp,
                    const int& lg,const pair<int,int>& start,const pair<int,int>& end)
{
    for(int i=0;i<lg;i++)
    {
        for(int j=0;j<lg;j++)
        {
            if(i==start.first && j==start.second)//起点
            {
                Mirror[i][j]=0;
                continue;
            } 
            if(i==end.first && j==end.second)//终点
            {
                Mirror[i][j]=0;
                continue;
            } 
            if(mp[i][j]==-2)//墙
            {
                Mirror[i][j]=-2;
                continue;
            }
            
            pair<int,int>Mp=colMirror(i,j,lg);int temp=0;//无法传送则为0
            if(check(Mp,lg) && mp[Mp.first][Mp.second]!=-2) temp=max(temp,mp[Mp.first][Mp.second]);//行列镜像选最大
            Mp=rowMirror(i,j,lg);
            if(check(Mp,lg) && mp[Mp.first][Mp.second]!=-2) temp=max(temp,mp[Mp.first][Mp.second]);//行列镜像选最大
            Mirror[i][j]=temp;
        }
    }
}

最后的重头戏，求答案，前面已经求出了传送后的距离，那么A只要选择一条路径上最大的值最小的路径就可以了，因为B肯定在A选的这条路径上的最大值位置进行传送，所以每条路径的值是这条路径中的最大值，A则要选一条值最小的路径

我本来~~（可以不看这行）~~用类似Prim算法（最小生成树算法，每次选最小点加入点集）的方式，从起点出发，每次选择相邻的最小的格子加入集合，直到没有格子能加入或者终点加入集合，TLE了，修修改改降不下时间复杂度，只能乖乖看大佬代码

先来一个优先队列排序用结构体

struct cmp1
{
    bool operator ()(const pair<int,pair<int,int>>& L,const pair<int,pair<int,int>>& R)
    {
        return L.first>R.first;
    }
};

大佬用了一个优先队列，存储三个整形数据：格子的传送后距离，格子的横坐标X和格子的纵坐标Y。

排序规则就是上面这个：按照最小的传送后距离优先排序，然后也是从起点开始，每次选集合里传送后距离最小的格子（然后要抛弃掉），上下左右延伸一个，然后新格子的传送值是MAX(自己，旧格子)，因为路径上的值实际上是路径中的最大值，而且由于每次是选集合里传送后距离最小的格子，且每次选完会用bool标记防止重复选取，所以传送后距离最小的格子优先延伸保证格子首先遇到的是它能遇到的最小的格子

计算答案的函数

void BFS_ans(vector<vector<int>>& Mirror,vector<vector<int>>& mp,
                    const int& lg,const pair<int,int>& start,const pair<int,int>& end)
{
    vector<pair<int,int>>move{{1,0},{-1,0},{0,1},{0,-1}};//四种移动方式 
    int ans=0;//什么都不是 
    vector<vector<bool>> book (lg,vector<bool>(lg,false)); //防止重复选择 
    priority_queue< pair<int,pair<int,int>> ,vector<pair<int,pair<int,int>>>, cmp1>nows;//绝中绝 
    nows.push({0,start});//起点开始 
    book[start.first][start.second]=1;//记录 
    while(!nows.empty())
    {
        pair<int,pair<int,int>>bignow=nows.top();nows.pop();
        pair<int,int>now=bignow.second;
        int nowx=now.first,nowy=now.second;//当前坐标 
        //cout<<"now"<<nowx<<" "<<nowy<<endl;
        for(auto pii:move)
        {
            int xx=nowx+pii.first,yy=nowy+pii.second;//移动后坐标 
            //cout<<xx<<"and"<<yy<<endl;
            if(check(xx,yy,lg) && book[xx][yy]==0 && Mirror[xx][yy]!=-2)
            {
                //cout<<xx<<"and"<<yy<<endl;
                //if(mp[xx][yy]>Mirror[xx][yy]) Mirror[xx][yy]=0;
                Mirror[xx][yy]=max(Mirror[xx][yy],Mirror[nowx][nowy]);
                nows.push({Mirror[xx][yy],{xx,yy}});
                book[xx][yy]=1;
            }
        }
        //cout<<"push"<<" val:"<<temp<<endl;
    }
}

负责会传答案和初始化地图的工具人函数

int challengeOfTheKeeper(vector<string>& maze)
{
    int lg=maze.size(),ans=0;//长度答案 
    pair<int,int>start,end;//起点 终点 
    vector<vector<int>>mp (lg,vector<int>(lg));
    vector<vector<int>>Mirror (lg,vector<int>(lg));
    
    for(int index=0;index<lg;index++)
    {
        for(int jndex=0;jndex<lg;jndex++)
        {
            if(maze[index][jndex]=='.') mp[index][jndex]=INT_MAX;//空地 int INT_MAX
            if(maze[index][jndex]=='#') mp[index][jndex]=-2;//墙壁 int -2
            if(maze[index][jndex]=='S')//初始位置 int INT_MAX
            {
                start.first=index;start.second=jndex;
                mp[index][jndex]=INT_MAX;
            }
            if(maze[index][jndex]=='T')//终点 int 0
            {
                end.first=index;end.second=jndex;
                mp[index][jndex]=0;
            }
        }
    }//更改地图存储方式
    BFS_Distance(mp,end,lg);//BFS更新距离
    BL_Mirror(Mirror,mp,lg,start,end);//遍历更新传送后距离 
    if(mp[start.first][start.second]==INT_MAX) return -1;
    BFS_ans(Mirror,mp,lg,start,end);//BFS获取答案
    
    /*cout<<"Mirror"<<endl;
    for(auto &i:Mirror)
    {
        for(auto &j:i)
        {
            printf("%02d ",j);
        }
        cout<<endl;
    }*/
    if(Mirror[end.first][end.second]==INT_MAX) return -1;
    else return Mirror[end.first][end.second];
}

可有可无的IDE里测试用main函数

int main()
{
    vector<string> maze;string s;
    while(cin>>s)
    {
        maze.push_back(s);
    }
    int ans=challengeOfTheKeeper(maze);
    cout<<ans<<endl;
    return 0;
}

实际代码：

#include<bits/stdc++.h>
using namespace std;
struct cmp1
{
    bool operator ()(const pair<int,pair<int,int>>& L,const pair<int,pair<int,int>>& R)
    {
        return L.first>R.first;
    }
};
bool check(const int& n,const int& m,const int& lg)//×ø±êºÏ·¨¼ì²é 
{
    if(n<0||m<0) return false;
    if(n>=lg||m>=lg) return false;
    return true;
}
bool check(const pair<int,int>& pa,const int& lg)//×ø±êºÏ·¨¼ì²é 
{
    const int n=pa.first,m=pa.second;
    if(n<0||m<0) return false;
    if(n>=lg||m>=lg) return false;
    return true;
}
inline pair<int,int> colMirror(const int& n,const int& m,const int& lg)//×óÓÒ¾µÏñ-ÁÐ¾µÏñ 
{
    return {n,lg-m-1};
}
inline pair<int,int> rowMirror(const int& n,const int& m,const int& lg)//ÉÏÏÂ¾µÏñ-ÐÐ¾µÏñ 
{
    return {lg-n-1,m};
}
void BFS_Distance(vector<vector<int>>& mp,const pair<int,int>& point,const int& lg)//ÀàËÆºéË®Ìî³ä 
{
    vector<pair<int,int>>now{point};//µ±Ç°×ø±ê 
    while(true)
    {
        vector<pair<int,int>>next;//ÏÂÒ»ÂÖ×ø±ê 
        for(auto pa:now)
        {
            int nowx=pa.first,nowy=pa.second,nowval=mp[nowx][nowy];
            if(check(nowx-1,nowy,lg) && mp[nowx-1][nowy]==INT_MAX)//¿ÕµØ-³õÊ¼Î»ÖÃ
            {
                mp[nowx-1][nowy]=nowval+1;//¸üÐÂ¾àÀë
                next.push_back(pair<int,int>{nowx-1,nowy});
            }
            if(check(nowx+1,nowy,lg) && mp[nowx+1][nowy]==INT_MAX)//¿ÕµØ-³õÊ¼Î»ÖÃ
            {
                mp[nowx+1][nowy]=nowval+1;//¸üÐÂ¾àÀë
                next.push_back(pair<int,int>{nowx+1,nowy});
            }
            if(check(nowx,nowy-1,lg) && mp[nowx][nowy-1]==INT_MAX)//¿ÕµØ-³õÊ¼Î»ÖÃ
            {
                mp[nowx][nowy-1]=nowval+1;//¸üÐÂ¾àÀë
                next.push_back(pair<int,int>{nowx,nowy-1});
            }
            if(check(nowx,nowy+1,lg) && mp[nowx][nowy+1]==INT_MAX)//¿ÕµØ-³õÊ¼Î»ÖÃ
            {
                mp[nowx][nowy+1]=nowval+1;//¸üÐÂ¾àÀë
                next.push_back(pair<int,int>{nowx,nowy+1});
            }
        }
        now=next;
        if(now.empty()) break;
    }
    /*cout<<"Distance"<<endl;
    for(auto &i:mp)
    {
        for(auto &j:i)
        {
            printf("%02d ",j);
        }
        cout<<endl;
    }*/
}
void BL_Mirror(vector<vector<int>>& Mirror,vector<vector<int>>& mp,
                    const int& lg,const pair<int,int>& start,const pair<int,int>& end)
{
    for(int i=0;i<lg;i++)
    {
        for(int j=0;j<lg;j++)
        {
            if(i==start.first && j==start.second)//Æðµã
            {
                Mirror[i][j]=0;
                continue;
            } 
            if(i==end.first && j==end.second)//ÖÕµã
            {
                Mirror[i][j]=0;
                continue;
            } 
            if(mp[i][j]==-2)//Ç½
            {
                Mirror[i][j]=-2;
                continue;
            }
            
            pair<int,int>Mp=colMirror(i,j,lg);int temp=0;
            if(check(Mp,lg) && mp[Mp.first][Mp.second]!=-2) temp=max(temp,mp[Mp.first][Mp.second]);//ÐÐÁÐ¾µÏñÑ¡×î´ó
            Mp=rowMirror(i,j,lg);
            if(check(Mp,lg) && mp[Mp.first][Mp.second]!=-2) temp=max(temp,mp[Mp.first][Mp.second]);//ÐÐÁÐ¾µÏñÑ¡×î´ó
            Mirror[i][j]=temp;
        }
    }
    /*cout<<"Mirror"<<endl;
    for(auto &i:Mirror)
    {
        for(auto &j:i)
        {
            printf("%02d ",j);
        }
        cout<<endl;
    }*/
}
void BFS_ans(vector<vector<int>>& Mirror,vector<vector<int>>& mp,
                    const int& lg,const pair<int,int>& start,const pair<int,int>& end)
{
    vector<pair<int,int>>move{{1,0},{-1,0},{0,1},{0,-1}};
    int ans=0;
    vector<vector<bool>> book (lg,vector<bool>(lg,false)); 
    priority_queue< pair<int,pair<int,int>> ,vector<pair<int,pair<int,int>>>, cmp1>nows;
    nows.push({0,start});
    book[start.first][start.second]=1;
    while(!nows.empty())
    {
        pair<int,pair<int,int>>bignow=nows.top();nows.pop();
        pair<int,int>now=bignow.second;
        int nowx=now.first,nowy=now.second;
        //cout<<"now"<<nowx<<" "<<nowy<<endl;
        for(auto pii:move)
        {
            int xx=nowx+pii.first,yy=nowy+pii.second;
            //cout<<xx<<"and"<<yy<<endl;
            if(check(xx,yy,lg) && book[xx][yy]==0 && Mirror[xx][yy]!=-2)
            {
                //cout<<xx<<"and"<<yy<<endl;
                //if(mp[xx][yy]>Mirror[xx][yy]) Mirror[xx][yy]=0;
                Mirror[xx][yy]=max(Mirror[xx][yy],Mirror[nowx][nowy]);
                nows.push({Mirror[xx][yy],{xx,yy}});
                book[xx][yy]=1;
            }
        }
        //cout<<"push"<<" val:"<<temp<<endl;
    }
}
int challengeOfTheKeeper(vector<string>& maze)
{
    int lg=maze.size(),ans=0;//³¤¶È´ð°¸ 
    pair<int,int>start,end;//Æðµã ÖÕµã 
    vector<vector<int>>mp (lg,vector<int>(lg));
    vector<vector<int>>Mirror (lg,vector<int>(lg));
    
    for(int index=0;index<lg;index++)
    {
        for(int jndex=0;jndex<lg;jndex++)
        {
            if(maze[index][jndex]=='.') mp[index][jndex]=INT_MAX;//¿ÕµØ int INT_MAX
            if(maze[index][jndex]=='#') mp[index][jndex]=-2;//Ç½±Ú int -2
            if(maze[index][jndex]=='S')//³õÊ¼Î»ÖÃ int INT_MAX
            {
                start.first=index;start.second=jndex;
                mp[index][jndex]=INT_MAX;
            }
            if(maze[index][jndex]=='T')//ÖÕµã int 0
            {
                end.first=index;end.second=jndex;
                mp[index][jndex]=0;
            }
        }
    }//¸ü¸ÄµØÍ¼´æ´¢·½Ê½
    BFS_Distance(mp,end,lg);//BFS¸üÐÂ¾àÀë
    BL_Mirror(Mirror,mp,lg,start,end);//±éÀú¸üÐÂ´«ËÍºó¾àÀë 
    if(mp[start.first][start.second]==INT_MAX) return -1;
    BFS_ans(Mirror,mp,lg,start,end);//BFS»ñÈ¡´ð°¸
    
    /*cout<<"Mirror"<<endl;
    for(auto &i:Mirror)
    {
        for(auto &j:i)
        {
            printf("%02d ",j);
        }
        cout<<endl;
    }*/
    if(Mirror[end.first][end.second]==INT_MAX) return -1;
    else return Mirror[end.first][end.second];
}
int main()
{
    vector<string> maze;string s;
    while(cin>>s)
    {
        maze.push_back(s);
    }
    int ans=challengeOfTheKeeper(maze);
    cout<<ans<<endl;
    return 0;
}

限制：