题意

给你地图，图中的$1$代表这里有根据地，你越靠近根据地，越容易被敌人发现，危险等级越高。不能从根据地中间穿过。 给你起点，终点，求最少的危险等级和使之可以到达，如果没有 输出，$no$ $solution$。 危险等级是这么定义的，你在某个点，这个点离它最近的根据地的距离为$d$，那么，这个点的危险等级就是，矩阵的长+宽-$d$。

标程

#include <iostream>
#include <queue>
#include <cstring>
#include <limits.h>
using namespace std;

const int MAX = 85;
int map[MAX][MAX];
int level[MAX][MAX];
int result[MAX][MAX];
int n, m;
struct Node {
    int x, y, lev;
};

queue<Node> q;

bool canNotVisit(int x, int y, int mode) {
    if (mode < 4) {
        if (mode == 0)
            return map[x-1][y-1] && map[x-1][y];
        else
            return map[x][y] && map[x][y-1];
    } else {
        if (mode == 4)
            return map[x][y-1] && map[x-1][y-1];
        else
            return map[x][y] && map[x-1][y];
    }
}

void pushQueue(int x, int y, int lev) {
    Node temp;
    temp.x = x;
    temp.y = y;
    temp.lev = lev;
    q.push(temp);
}

int main() {
    int dis[] = {-1, 0, 1, 0, 0, -1, 0, 1};
    int ncases;
    char ch;
    int x, y, lev, a, b;
    cin >> ncases;
    while (ncases--) {
        cin >> n >> m;
        Node start, end;
        cin >> start.x >> start.y >> end.x >> end.y;

        memset(map, 0, sizeof(map));
        memset(level, 0, sizeof(level));
        for (int i = 0; i <= n; ++i)
            for (int j = 0; j <= m; ++j)
                result[i][j] = INT_MAX;

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                cin >> ch;
                map[i][j] = ch - '0';
                if (map[i][j]) {
                    level[i][j] = level[i][j+1] = level[i+1][j] = level[i+1][j+1] = n + m;
                    pushQueue(i, j, n + m);
                    pushQueue(i, j + 1, n + m);
                    pushQueue(i + 1, j, n + m);
                    pushQueue(i + 1, j + 1, n + m);
                }
            }
        }

        while (!q.empty()) {
            Node temp = q.front();
            q.pop();
            x = temp.x;
            y = temp.y;
            lev = temp.lev - 1;
            for (int i = 0; i < 8; i += 2) {
                a = x + dis[i];
                b = y + dis[i + 1];
                if (a >= 0 && a <= n && b >= 0 && b <= m && !canNotVisit(x, y, i) && lev > level[a][b]) {
                    level[a][b] = lev;
                    pushQueue(a, b, lev);
                }
            }
        }

        start.lev = result[start.x][start.y] = level[start.x][start.y];
        end.lev = level[end.x][end.y];
        q.push(start);
        while (!q.empty()) {
            Node temp = q.front();
            q.pop();
            x = temp.x;
            y = temp.y;
            lev = temp.lev;
            for (int i = 0; i < 8; i += 2) {
                a = x + dis[i];
                b = y + dis[i + 1];
                if (a >= 0 && a <= n && b >= 0 && b <= m && !canNotVisit(x, y, i) && lev + level[a][b] < result[a][b]) {
                    result[a][b] = lev + level[a][b];
                    Node ntemp;
                    ntemp.x = a;
                    ntemp.y = b;
                    ntemp.lev = result[a][b];
                    q.push(ntemp);
                }
            }
        }

        if (result[end.x][end.y] == INT_MAX)
            cout << "no solution" << endl;
        else
            cout << result[end.x][end.y] << endl;
    }
    return 0;
}