染色时间 困难 蓝桥杯省赛 2022

问题描述
小蓝有一个 n 行 m 列的白色棋盘, 棋盘的每一个方格都可以被染成彩色。
每个方格有一个染色时间 t , 不同方格的染色时间可能不同。如果一个方 格被触发了染色, 这个方格就会在 t 秒之后变成彩色, 然后将自己上下左右四 个方向相邻的方格触发染色。每个方格只能被触发染色一次, 第一次触发之后 的触发为无效触发。

给定每个方格的染色时间, 在时刻 0 触发第一行第一列的方格染色, 请问 多长时间后整个棋盘完成染色。

输入格式
输入的第一行包含两个整数 ,n,m, 分别表示棋盘的行数和列数。接下来 n 行, 每行 m 个正整数, 相邻的整数之间用一个空格分隔, 表示每 个方格的染色时间。该部分的第 i 行第 j 个整数表示 t (ij) , 即第 i 行第 j 列的方 格的染色时间。

输出格式
输出一行包含一个整数, 表示整个棋盘完成染色的时间。

样例输入

2 3

1 2 3

4 5 6

样例输出

12

思路
以样例来说，(0,0)的位置首先花一秒进行染色，接下来待染色的就是(0,1) (1,0)
再加上已经花费了的一秒，用图解来表示就是

0 3
5

也就是右边需要三秒染色，下面需要五秒染色，所以下一个状态就是右边染色成功后四周的也准备染色，染色时间就是这个点需要的时间+3

0 0 6
5 8

接下来就该(1,0)在第五秒的时候染色成功了，但它周围全都染过色了vis true过了

0 0 6    0 0 0     0 0 0
0 8      0 8 12    0 0 12

所以，整体思路还是用bfs来写，不过相比于传统的队列，我们更希望有一个类似队列而且可以按照时间排序的工具，就是set了，然后在传统的结构体中加入按时间优先排列的重载小于号
注意不能只写return tim < no.tim;这样会导致相同时间的不同坐标被去重
更具体的在代码的注释里了

#include <bits/stdc++.h>
using namespace std;
int mp[505][505];  //储存地图
bool vis[505][505];  //是否走过
int n,m;
int dir[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};  //四个方向
bool in(int x,int y){    //xy是否在地图里
    if (x>=0&&y>=0&&x<n&&y<m) return true;
    else return false;
}
struct node{
    int x,y;
    long long tim;
    node(int xx,int yy,long long tt){
        x = xx;
        y = yy;
        tim = tt;
    }
    //重载小于号
    bool operator < (const node no) const{
		if(tim!=no.tim) return tim < no.tim;
        else if(x!=no.x) return x < no.x;
        else return y < no.y;
    }
};
set<node> s;
int bfs(){
    while(!s.empty()){
    //首个元素一定是染色时间最短的
        int tx = s.begin()->x;
        int ty = s.begin()->y;
        long long tt = s.begin()->tim;
        vis[tx][ty] = true;
        s.erase(s.begin());    //删除首个元素
        for (int i = 0; i < 4; i++) {
            int ttx = tx + dir[i][0];
            int tty = ty + dir[i][1];
            if (!vis[ttx][tty]&&in(ttx,tty)) {  //如果上下左右四个方向在地图里且没被访问过就入队（集合）
                long long ttm = tt + mp[ttx][tty];
                s.insert(node(ttx,tty,ttm));
                vis[ttx][tty] = true;
            }
        }
        //花费时间总体最长的就是整个地图需要的时间，一定在队尾
        if (s.size()==1) return s.begin()->tim;
    }
    return 0;
}
int main(){
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> mp[i][j];
        }
    }
    vis[0][0] = true;
    s.insert(node(1,0,mp[0][0]+mp[1][0]));  //向右
    s.insert(node(0,1,mp[0][0]+mp[0][1]));  //向下
    cout << bfs();
    return 0;
}

这题我都能做出来，应该算个中等题，困难有点说不上