题目要求
给定一个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,最小减为0,表示无信号,即肯定无法传播
- 当某个位置可以同时接收到多个基站的信号时,取其中接收信号强度的最大值作为该位置的信号强度。
- 假设接收到的信号强度低于门限Th ,信号就会中断。
- 得从左上角移动到右下角过程中信号不中断,只能上下左右移动
综上
- 先构造出地图,该地图应该具备每个坐标的信号大小
- 从0,0 往 n-1,m-1移动
- 移动过程要避信号小于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});
}
}
}
}