通话不中断的最短路径

题目要求

给定一个MxN的网格，其中每个单元格都填有数字，数字大小表示覆盖信号强度。灰色网格代表空地，橙色网格代表信号覆盖区域，绿色网格代表基站，绿色网格内数字大小表示该基站发射信号的初始强度。

基站信号每向外（上下左右）传播一格，信号强度减1，最小减为0，表示无信号，如下图示。当某个位置可以同时接收到多个基站的信号时，取其中接收信号强度的最大值作为该位置的信号强度。

对于给定网格，请判断是否存在一条路径，使得从左上角移动到右下角过程中信号不中断，只能上下左右移动。假设接收到的信号强度低于门限Th ，信号就会中断。

注意:出发点固定在网格的左上角，终点是网格的右下角。

输入描述

第一行输入信号强度Th。 (1<= Th <= 100)

第二行输入矩阵M、N。 (1<= M <= 100，1<= N <= 100)

第三行输入基站个数K。 (1<= K <= 100)

后续K行输入基站位置及初始信号强度。(前两个值表示基站所在行、列索引，第3个值表示基站初始信号强度)

输出描述

返回信号不中断的最短路径，不存在返回0

示例

输入：
1
4 5
2
0 1 2
3 2 3

输出：
8

解释: 
1) 信号强度门限Th = 1
2) M=4，N=5
3) 4*5网格中一共包含2个基站
4) 2个基站的位置，其中第1个基站在第0行第1列、初始信号强度 =2;第2个基站在第3行第2列、初始信号强度=3

解题思路

整理出限制：

1. 上下左右）传播一格，信号强度减1，最小减为0，表示无信号，即肯定无法传播
2. 当某个位置可以同时接收到多个基站的信号时，取其中接收信号强度的最大值作为该位置的信号强度。
3. 假设接收到的信号强度低于门限Th ，信号就会中断。
4. 得从左上角移动到右下角过程中信号不中断，只能上下左右移动

综上

1. 先构造出地图，该地图应该具备每个坐标的信号大小
2. 从0，0 往 n-1,m-1移动
3. 移动过程要避信号小于Th

代码

package com.example.demo.algorithm;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;

/**
 * @Desc: 通话不中断的最短路径
 * @Auther:chenLing
 * @Date: 2024/7/18 10:34
 */
public class Test03 {
    static final int[] DX = {0, 1, 0, -1};
    static final int[] DY = {1, 0, -1, 0};
    static Map<Integer, List<List<String>>> Load_MAP = new HashMap<>();
    static Integer STEP = 0;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int minValue = Integer.parseInt(sc.nextLine());
        int[] sizes = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int m = sizes[0];
        int n = sizes[1];
        STEP = m * n * 2;
        int target = Integer.parseInt(sc.nextLine());
        // 收集基站
        Queue<int[]> queue = new ArrayDeque<>();
        int[][] mapArr = new int[n][m];
        for (int i = 0; i < target; i++) {
            int[] temp = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            mapArr[temp[0]][temp[1]] = temp[2];
            queue.offer(temp);
        }
        sc.close();
        // 填充各坐标的信号强度
        buildMap(minValue, m, n, queue, mapArr);
        // 起点判断
        if (mapArr[0][0] < minValue) {
            System.out.println(0);
            return;
        }
        // 收集路径坐标
        List<String> load = new ArrayList<>();
        load.add("0,0");
        findLoad(new int[]{0, 0}, new int[]{n, m, minValue}, mapArr, load);
        if (STEP == m * n * 2) {
            System.out.println(0);
        } else {
            System.out.println(STEP - 1);
        }
    }

    /**
     * @Desc: 通话不中断的最短路径
     * @param indexs : 当前的坐标
     * @param mapInfo : 地图的最大信息m n 和最小信号minValue
     * @param mapArr : 地图
     * @param load : 路径坐标
     * @Auther:chenLing
     * @Date: 2024/7/18 10:34
     */
    private static void findLoad(int[] indexs, int[] mapInfo, int[][] mapArr, List<String> load) {
        for (int i = 0; i < 4; i++) {
            int xx = indexs[0] + DX[i];
            int yy = indexs[1] + DY[i];
            String key = xx + "," + yy;
            // 越界 或 假设接收到的信号强度低于门限Th ，信号就会中断
            // 或 该路径已经过该点
            // 或步骤比已探索路径只少一步，则不需要
            if (xx < 0 || xx >= mapInfo[0] || yy < 0 || yy >= mapInfo[1]
                || mapArr[xx][yy] < mapInfo[2]
                || load.contains(key)
                || load.size() >= STEP - 1) {
                continue;
            }
            load.add(key);
            if (xx == mapInfo[0] - 1 && yy == mapInfo[1] - 1) {
                int size = load.size();
                if (STEP > size) {
                    STEP = size;
                }
                // 此处代码是为了汇总全部路径做对比，本题不需要，所以其实不需要Load_MAP
                List<List<String>> orDefault = Load_MAP.getOrDefault(size, new ArrayList<>());
                orDefault.add(new ArrayList<>(load));
                Load_MAP.put(size, orDefault);
                // 探索后移除
                load.remove(size - 1);
                return;
            }
            findLoad(new int[]{xx, yy}, mapInfo, mapArr, load);
            // 探索后移除
            load.remove(load.size() - 1);
        }
    }


    private static void buildMap(int minValue, int m, int n, Queue<int[]> queue, int[][] mapArr) {
        while (!queue.isEmpty()) {
            int[] temp = queue.poll();
            int x = temp[0];
            int y = temp[1];
            // 基站信号每向外（上下左右）传播一格，信号强度减1，最小减为0，表示无信号,
            // 假设接收到的信号强度低于门限Th ，信号就会中断,就没必要往下扩散
            int step = temp[2] - 1;
            if (step < minValue || step < 0) {
                continue;
            }
            for (int i = 0; i < 4; i++) {
                int xx = x + DX[i];
                int yy = y + DY[i];
                // 越界 或 本身的信号强度大于当前强度
                if (xx < 0 || xx >= n || yy < 0 || yy >= m || mapArr[xx][yy] > step) {
                    continue;
                }
                mapArr[xx][yy] = step;
                queue.offer(new int[]{xx, yy, step});
            }
        }
    }

}